1 // $ANTLR 2.7.2: "java.g" -> "JavaRecognizer.java"$
2 /* FOREGEJ - FOrmatting REfactoring GEnerating Java
3 *
4 * Copyright (C) 2003 Andreas Arrgard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20 package com.octagroup.foregej.java.lang;
21 import antlr.TokenBuffer;
22 import antlr.TokenStreamException;
23 import antlr.Token;
24 import antlr.TokenStream;
25 import antlr.RecognitionException;
26 import antlr.NoViableAltException;
27 import antlr.ParserSharedInputState;
28 import antlr.collections.impl.BitSet;
29 import antlr.collections.AST;
30 import antlr.ASTFactory;
31 import antlr.ASTPair;
32 import antlr.collections.impl.ASTArray;
33 /***
34 * Java 1.3 Recognizer Run 'java Main [-showtree]
35 * directory-full-of-java-files' [The -showtree option pops up a Swing
36 * frame that shows the AST constructed from the parser.] Run 'java Main
37 * <directory full of java files>' Contributing authors: John Mitchell
38 * johnm
39 *
40 * @empathy.com Scott Stanchfield thetick
41 * @eng.sun.com Steve Messick messick
42 * @informatik.rwth -aachen.de Peter Williams pete.williams
43 * @magelang.com John Lilley jlilley
44 * @magelang.com Markus Mohnen mohnen
45 * @non.net Terence Parr parrt
46 * @pybus.org Version 1.00 December 9, 1997 -- initial release Version
47 * 1.01 December 10, 1997 fixed bug in octal def (0..7 not 0..8) Version
48 * 1.10 August 1998 (parrt) added tree construction fixed definition of
49 * WS,comments for mac,pc,unix newlines added unary plus Version 1.11 (Nov
50 * 20, 1998) Added "shutup" option to turn off last ambig warning. Fixed
51 * inner class def to allow named class defs as statements synchronized
52 * requires compound not simple statement add [] after builtInType DOT
53 * class in primaryExpression "const" is reserved but not valid..removed
54 * from modifiers Version 1.12 (Feb 2, 1999) Changed LITERAL_xxx to xxx in
55 * tree grammar. Updated java.g to use tokens {...} now for 2.6.0 (new
56 * feature). Version 1.13 (Apr 23, 1999) Didn't have (stat)? for else
57 * clause in tree parser. Didn't gen ASTs for interface extends. Updated
58 * tree parser too. Updated to 2.6.0. Version 1.14 (Jun 20, 1999) Allowed
59 * final/abstract on local classes. Removed local interfaces from methods
60 * Put instanceof precedence where it belongs...in relationalExpr It also
61 * had expr not type as arg; fixed it. Missing ! on SEMI in classBlock
62 * fixed: (expr) + "string" was parsed incorrectly (+ as unary plus).
63 * fixed: didn't like Object[].class in parser or tree parser Version 1.15
64 * (Jun 26, 1999) Screwed up rule with instanceof in it. :( Fixed. Tree
65 * parser didn't like (expr).something; fixed. Allowed multiple
66 * inheritance in tree grammar. oops. Version 1.16 (August 22, 1999)
67 * Extending an interface built a wacky tree: had extra EXTENDS. Tree
68 * grammar didn't allow multiple superinterfaces. Tree grammar didn't
69 * allow empty var initializer: {} Version 1.17 (October 12, 1999) ESC
70 * lexer rule allowed 399 max not 377 max. java.tree.g didn't handle the
71 * expression of synchronized statements. Version 1.18 (August 12, 2001)
72 * Terence updated to Java 2 Version 1.3 by observing/combining work of
73 * Allan Jacobs and Steve Messick. Handles 1.3 src. Summary: o primary
74 * didn't include boolean.class kind of thing o constructor calls parsed
75 * explicitly now: see explicitConstructorInvocation o add strictfp
76 * modifier o missing objBlock after new expression in tree grammar o
77 * merged local class definition alternatives, moved after declaration o
78 * fixed problem with ClassName.super.field o reordered some alternatives
79 * to make things more efficient o long and double constants were not
80 * differentiated from int/float o whitespace rule was inefficient:
81 * matched only one char o add an examples directory with some nasty 1.3
82 * cases o made Main.java use buffered IO and a Reader for Unicode support
83 * o supports UNICODE? Using Unicode charVocabulay makes code file big,
84 * but only in the bitsets at the end. I need to make ANTLR generate
85 * unicode bitsets more efficiently. Version 1.19 (April 25, 2002) Terence
86 * added in nice fixes by John Pybus concerning floating constants and
87 * problems with super() calls. John did a nice reorg of the
88 * primary/postfix expression stuff to read better and makes f.g.super()
89 * parse properly (it was METHOD_CALL not a SUPER_CTOR_CALL). Also: o
90 * "finally" clause was a root...made it a child of "try" o Added stuff
91 * for asserts too for Java 1.4, but *commented out* as it is not backward
92 * compatible. Version 1.20 (October 27, 2002) Terence ended up reorging
93 * John Pybus' stuff to remove some nondeterminisms and some syntactic
94 * predicates. Note that the grammar is stricter now; e.g., this(...) must
95 * be the first statement. Trinary ?: operator wasn't working as array
96 * name: (isBig ? bigDigits : digits)[i]; Checked parser/tree parser on
97 * source for Resin-2.0.5, jive-2.1.1, jdk 1.3.1, Lucene, antlr 2.7.2a4,
98 * and the 110k-line jGuru server source. This grammar is in the PUBLIC
99 * DOMAIN
100 * @redhills.com John Pybus john
101 * @sun.com Allan Jacobs Allan.Jacobs
102 */
103 public class JavaRecognizer extends JavaRecognizerBase implements JavaTokenTypes
104 {
105 protected JavaRecognizer(TokenBuffer tokenBuf,int k)
106 {
107 super(tokenBuf, k);
108 tokenNames=_tokenNames;
109 buildTokenTypeASTClassMap();
110 astFactory=new ASTFactory(getTokenTypeToASTClassMap());
111 }
112 public JavaRecognizer(TokenBuffer tokenBuf)
113 {
114 this(tokenBuf, 2);
115 }
116 protected JavaRecognizer(TokenStream lexer,int k)
117 {
118 super(lexer, k);
119 tokenNames=_tokenNames;
120 buildTokenTypeASTClassMap();
121 astFactory=new ASTFactory(getTokenTypeToASTClassMap());
122 }
123 public JavaRecognizer(TokenStream lexer)
124 {
125 this(lexer, 2);
126 }
127 public JavaRecognizer(ParserSharedInputState state)
128 {
129 super(state, 2);
130 tokenNames=_tokenNames;
131 buildTokenTypeASTClassMap();
132 astFactory=new ASTFactory(getTokenTypeToASTClassMap());
133 }
134 /***
135 */
136 public final void compilationUnit() throws RecognitionException,
137 TokenStreamException
138 {
139 returnAST=null;
140 ASTPair currentAST=new ASTPair();
141 AST compilationUnit_AST=null;
142 {
143 switch(LA(1)) {
144 case LITERAL_package:
145
146 {
147 packageDefinition();
148 astFactory.addASTChild(currentAST, returnAST);
149 break;
150 }
151 case EOF:
152 case FINAL:
153 case ABSTRACT:
154 case STRICTFP:
155 case SEMI:
156 case LITERAL_import:
157 case LITERAL_private:
158 case LITERAL_public:
159 case LITERAL_protected:
160 case LITERAL_static:
161 case LITERAL_transient:
162 case LITERAL_native:
163 case LITERAL_threadsafe:
164 case LITERAL_synchronized:
165 case LITERAL_volatile:
166 case LITERAL_class:
167 case LITERAL_interface:
168
169 {
170 break;
171 }
172 default:
173
174 {
175 throw new NoViableAltException(LT(1), getFilename());
176 }
177 }
178 }
179 {
180 _loop4:
181
182 do {
183 if(LA(1)==LITERAL_import) {
184 importDefinition();
185 astFactory.addASTChild(currentAST, returnAST);
186 } else {
187 break _loop4;
188 }
189 } while(true);
190
191 }
192 {
193 _loop6:
194
195 do {
196 if(_tokenSet_0.member(LA(1))) {
197 typeDefinition();
198 astFactory.addASTChild(currentAST, returnAST);
199 } else {
200 break _loop6;
201 }
202 } while(true);
203
204 }
205 match(Token.EOF_TYPE);
206 compilationUnit_AST=(AST)currentAST.root;
207 returnAST=compilationUnit_AST;
208 }
209 /***
210 */
211 public final void packageDefinition() throws RecognitionException,
212 TokenStreamException
213 {
214 returnAST=null;
215 ASTPair currentAST=new ASTPair();
216 AST packageDefinition_AST=null;
217 Token p=null;
218 AST p_AST=null;
219 try{
220 // for error handling
221 p=LT(1);
222 p_AST=astFactory.create(p);
223 astFactory.makeASTRoot(currentAST, p_AST);
224 match(LITERAL_package);
225 if(inputState.guessing==0) {
226 p_AST.setType(PACKAGE_DEF);
227 }
228 identifier();
229 astFactory.addASTChild(currentAST, returnAST);
230 match(SEMI);
231 packageDefinition_AST=(AST)currentAST.root;
232 }catch (RecognitionException ex) {
233 if(inputState.guessing==0) {
234 reportError(ex);
235 consume();
236 consumeUntil(_tokenSet_1);
237 } else {
238 throw ex;
239 }
240 }
241 returnAST=packageDefinition_AST;
242 }
243 /***
244 */
245 public final void importDefinition() throws RecognitionException,
246 TokenStreamException
247 {
248 returnAST=null;
249 ASTPair currentAST=new ASTPair();
250 AST importDefinition_AST=null;
251 Token i=null;
252 AST i_AST=null;
253 try{
254 // for error handling
255 i=LT(1);
256 i_AST=astFactory.create(i);
257 astFactory.makeASTRoot(currentAST, i_AST);
258 match(LITERAL_import);
259 if(inputState.guessing==0) {
260 i_AST.setType(IMPORT);
261 }
262 identifierStar();
263 astFactory.addASTChild(currentAST, returnAST);
264 match(SEMI);
265 importDefinition_AST=(AST)currentAST.root;
266 }catch (RecognitionException ex) {
267 if(inputState.guessing==0) {
268 reportError(ex);
269 consume();
270 consumeUntil(_tokenSet_1);
271 } else {
272 throw ex;
273 }
274 }
275 returnAST=importDefinition_AST;
276 }
277 /***
278 */
279 public final void typeDefinition() throws RecognitionException,
280 TokenStreamException
281 {
282 returnAST=null;
283 ASTPair currentAST=new ASTPair();
284 AST typeDefinition_AST=null;
285 AST m_AST=null;
286 try{
287 // for error handling
288 switch(LA(1)) {
289 case FINAL:
290 case ABSTRACT:
291 case STRICTFP:
292 case LITERAL_private:
293 case LITERAL_public:
294 case LITERAL_protected:
295 case LITERAL_static:
296 case LITERAL_transient:
297 case LITERAL_native:
298 case LITERAL_threadsafe:
299 case LITERAL_synchronized:
300 case LITERAL_volatile:
301 case LITERAL_class:
302 case LITERAL_interface:
303
304 {
305 modifiers();
306 m_AST=(AST)returnAST;
307 {
308 switch(LA(1)) {
309 case LITERAL_class:
310
311 {
312 classDefinition(m_AST);
313 astFactory.addASTChild(currentAST,
314 returnAST);
315 break;
316 }
317 case LITERAL_interface:
318
319 {
320 interfaceDefinition(m_AST);
321 astFactory.addASTChild(currentAST,
322 returnAST);
323 break;
324 }
325 default:
326
327 {
328 throw new NoViableAltException(LT(1),
329 getFilename());
330 }
331 }
332 }
333 typeDefinition_AST=(AST)currentAST.root;
334 break;
335 }
336 case SEMI:
337
338 {
339 match(SEMI);
340 typeDefinition_AST=(AST)currentAST.root;
341 break;
342 }
343 default:
344
345 {
346 throw new NoViableAltException(LT(1), getFilename());
347 }
348 }
349 }catch (RecognitionException ex) {
350 if(inputState.guessing==0) {
351 reportError(ex);
352 consume();
353 consumeUntil(_tokenSet_2);
354 } else {
355 throw ex;
356 }
357 }
358 returnAST=typeDefinition_AST;
359 }
360 /***
361 */
362 public final void identifier() throws RecognitionException,
363 TokenStreamException
364 {
365 returnAST=null;
366 ASTPair currentAST=new ASTPair();
367 AST identifier_AST=null;
368 AST tmp5_AST=null;
369 tmp5_AST=astFactory.create(LT(1));
370 astFactory.addASTChild(currentAST, tmp5_AST);
371 match(IDENT);
372 {
373 _loop23:
374
375 do {
376 if(LA(1)==DOT) {
377 AST tmp6_AST=null;
378 tmp6_AST=astFactory.create(LT(1));
379 astFactory.makeASTRoot(currentAST, tmp6_AST);
380 match(DOT);
381 AST tmp7_AST=null;
382 tmp7_AST=astFactory.create(LT(1));
383 astFactory.addASTChild(currentAST, tmp7_AST);
384 match(IDENT);
385 } else {
386 break _loop23;
387 }
388 } while(true);
389
390 }
391 identifier_AST=(AST)currentAST.root;
392 returnAST=identifier_AST;
393 }
394 /***
395 */
396 public final void identifierStar() throws RecognitionException,
397 TokenStreamException
398 {
399 returnAST=null;
400 ASTPair currentAST=new ASTPair();
401 AST identifierStar_AST=null;
402 AST tmp8_AST=null;
403 tmp8_AST=astFactory.create(LT(1));
404 astFactory.addASTChild(currentAST, tmp8_AST);
405 match(IDENT);
406 {
407 _loop26:
408
409 do {
410 if(LA(1)==DOT&&LA(2)==IDENT) {
411 AST tmp9_AST=null;
412 tmp9_AST=astFactory.create(LT(1));
413 astFactory.makeASTRoot(currentAST, tmp9_AST);
414 match(DOT);
415 AST tmp10_AST=null;
416 tmp10_AST=astFactory.create(LT(1));
417 astFactory.addASTChild(currentAST, tmp10_AST);
418 match(IDENT);
419 } else {
420 break _loop26;
421 }
422 } while(true);
423
424 }
425 {
426 switch(LA(1)) {
427 case DOT:
428
429 {
430 AST tmp11_AST=null;
431 tmp11_AST=astFactory.create(LT(1));
432 astFactory.makeASTRoot(currentAST, tmp11_AST);
433 match(DOT);
434 AST tmp12_AST=null;
435 tmp12_AST=astFactory.create(LT(1));
436 astFactory.addASTChild(currentAST, tmp12_AST);
437 match(STAR);
438 break;
439 }
440 case SEMI:
441
442 {
443 break;
444 }
445 default:
446
447 {
448 throw new NoViableAltException(LT(1), getFilename());
449 }
450 }
451 }
452 identifierStar_AST=(AST)currentAST.root;
453 returnAST=identifierStar_AST;
454 }
455 /***
456 */
457 public final void modifiers() throws RecognitionException,
458 TokenStreamException
459 {
460 returnAST=null;
461 ASTPair currentAST=new ASTPair();
462 AST modifiers_AST=null;
463 {
464 _loop30:
465
466 do {
467 if(_tokenSet_3.member(LA(1))) {
468 modifier();
469 astFactory.addASTChild(currentAST, returnAST);
470 } else {
471 break _loop30;
472 }
473 } while(true);
474
475 }
476 if(inputState.guessing==0) {
477 modifiers_AST=(AST)currentAST.root;
478 modifiers_AST=(AST)astFactory.make((new ASTArray(2)).add(astFactory.create(MODIFIERS,
479 "MODIFIERS")).add(modifiers_AST));
480 currentAST.root=modifiers_AST;
481 currentAST.child=((modifiers_AST!=null&&
482 modifiers_AST.getFirstChild()!=null)?modifiers_AST.getFirstChild():modifiers_AST);
483 currentAST.advanceChildToEnd();
484 }
485 modifiers_AST=(AST)currentAST.root;
486 returnAST=modifiers_AST;
487 }
488 /***
489 * @param modifiers
490 */
491 public final void classDefinition(AST modifiers) throws RecognitionException,
492 TokenStreamException
493 {
494 returnAST=null;
495 ASTPair currentAST=new ASTPair();
496 AST classDefinition_AST=null;
497 AST sc_AST=null;
498 AST ic_AST=null;
499 AST cb_AST=null;
500 match(LITERAL_class);
501 AST tmp14_AST=null;
502 tmp14_AST=astFactory.create(LT(1));
503 match(IDENT);
504 superClassClause();
505 sc_AST=(AST)returnAST;
506 implementsClause();
507 ic_AST=(AST)returnAST;
508 classBlock();
509 cb_AST=(AST)returnAST;
510 if(inputState.guessing==0) {
511 classDefinition_AST=(AST)currentAST.root;
512 classDefinition_AST=(AST)astFactory.make((new ASTArray(6)).add(astFactory.create(CLASS_DEF,
513 "CLASS_DEF")).add(modifiers).add(tmp14_AST).add(sc_AST).add(ic_AST).add(cb_AST));
514 currentAST.root=classDefinition_AST;
515 currentAST.child=((classDefinition_AST!=null&&
516 classDefinition_AST.getFirstChild()!=null)?classDefinition_AST.getFirstChild():classDefinition_AST);
517 currentAST.advanceChildToEnd();
518 }
519 returnAST=classDefinition_AST;
520 }
521 /***
522 * @param modifiers
523 */
524 public final void interfaceDefinition(AST modifiers) throws RecognitionException,
525 TokenStreamException
526 {
527 returnAST=null;
528 ASTPair currentAST=new ASTPair();
529 AST interfaceDefinition_AST=null;
530 AST ie_AST=null;
531 AST cb_AST=null;
532 match(LITERAL_interface);
533 AST tmp16_AST=null;
534 tmp16_AST=astFactory.create(LT(1));
535 match(IDENT);
536 interfaceExtends();
537 ie_AST=(AST)returnAST;
538 classBlock();
539 cb_AST=(AST)returnAST;
540 if(inputState.guessing==0) {
541 interfaceDefinition_AST=(AST)currentAST.root;
542 interfaceDefinition_AST=(AST)astFactory.make((new ASTArray(5)).add(astFactory.create(INTERFACE_DEF,
543 "INTERFACE_DEF")).add(modifiers).add(tmp16_AST).add(ie_AST).add(cb_AST));
544 currentAST.root=interfaceDefinition_AST;
545 currentAST.child=((interfaceDefinition_AST!=null&&
546 interfaceDefinition_AST.getFirstChild()!=null)?interfaceDefinition_AST.getFirstChild():interfaceDefinition_AST);
547 currentAST.advanceChildToEnd();
548 }
549 returnAST=interfaceDefinition_AST;
550 }
551 /***
552 * A declaration is the creation of a reference or primitive-type
553 * variable Create a separate Type/Var tree for each var in the var
554 * list.
555 */
556 public final void declaration() throws RecognitionException,
557 TokenStreamException
558 {
559 returnAST=null;
560 ASTPair currentAST=new ASTPair();
561 AST declaration_AST=null;
562 AST m_AST=null;
563 AST t_AST=null;
564 AST v_AST=null;
565 modifiers();
566 m_AST=(AST)returnAST;
567 typeSpec(false);
568 t_AST=(AST)returnAST;
569 variableDefinitions(m_AST, t_AST);
570 v_AST=(AST)returnAST;
571 if(inputState.guessing==0) {
572 declaration_AST=(AST)currentAST.root;
573 declaration_AST=v_AST;
574 currentAST.root=declaration_AST;
575 currentAST.child=((declaration_AST!=null&&
576 declaration_AST.getFirstChild()!=null)?declaration_AST.getFirstChild():declaration_AST);
577 currentAST.advanceChildToEnd();
578 }
579 returnAST=declaration_AST;
580 }
581 /***
582 * @param addImagNode
583 */
584 public final void typeSpec(boolean addImagNode) throws RecognitionException,
585 TokenStreamException
586 {
587 returnAST=null;
588 ASTPair currentAST=new ASTPair();
589 AST typeSpec_AST=null;
590 switch(LA(1)) {
591 case IDENT:
592
593 {
594 classTypeSpec(addImagNode);
595 astFactory.addASTChild(currentAST, returnAST);
596 typeSpec_AST=(AST)currentAST.root;
597 break;
598 }
599 case LITERAL_void:
600 case LITERAL_boolean:
601 case LITERAL_byte:
602 case LITERAL_char:
603 case LITERAL_short:
604 case LITERAL_int:
605 case LITERAL_float:
606 case LITERAL_long:
607 case LITERAL_double:
608
609 {
610 builtInTypeSpec(addImagNode);
611 astFactory.addASTChild(currentAST, returnAST);
612 typeSpec_AST=(AST)currentAST.root;
613 break;
614 }
615 default:
616
617 {
618 throw new NoViableAltException(LT(1), getFilename());
619 }
620 }
621 returnAST=typeSpec_AST;
622 }
623 /***
624 * @param mods
625 * @param t
626 */
627 public final void variableDefinitions(AST mods,
628 AST t) throws RecognitionException,
629 TokenStreamException
630 {
631 returnAST=null;
632 ASTPair currentAST=new ASTPair();
633 AST variableDefinitions_AST=null;
634 variableDeclarator(getASTFactory().dupTree(mods),
635 getASTFactory().dupTree(t));
636 astFactory.addASTChild(currentAST, returnAST);
637 {
638 _loop59:
639
640 do {
641 if(LA(1)==COMMA) {
642 match(COMMA);
643 variableDeclarator(getASTFactory().dupTree(mods),
644 getASTFactory().dupTree(t));
645 astFactory.addASTChild(currentAST, returnAST);
646 } else {
647 break _loop59;
648 }
649 } while(true);
650
651 }
652 variableDefinitions_AST=(AST)currentAST.root;
653 returnAST=variableDefinitions_AST;
654 }
655 /***
656 * @param addImagNode
657 */
658 public final void classTypeSpec(boolean addImagNode) throws RecognitionException,
659 TokenStreamException
660 {
661 returnAST=null;
662 ASTPair currentAST=new ASTPair();
663 AST classTypeSpec_AST=null;
664 Token lb=null;
665 AST lb_AST=null;
666 identifier();
667 astFactory.addASTChild(currentAST, returnAST);
668 {
669 _loop15:
670
671 do {
672 if(LA(1)==LBRACK) {
673 lb=LT(1);
674 lb_AST=astFactory.create(lb);
675 astFactory.makeASTRoot(currentAST, lb_AST);
676 match(LBRACK);
677 if(inputState.guessing==0) {
678 lb_AST.setType(ARRAY_DECLARATOR);
679 }
680 match(RBRACK);
681 } else {
682 break _loop15;
683 }
684 } while(true);
685
686 }
687 if(inputState.guessing==0) {
688 classTypeSpec_AST=(AST)currentAST.root;
689 if(addImagNode) {
690 classTypeSpec_AST=(AST)astFactory.make((new ASTArray(2)).add(astFactory.create(TYPE,
691 "TYPE")).add(classTypeSpec_AST));
692 }
693 currentAST.root=classTypeSpec_AST;
694 currentAST.child=((classTypeSpec_AST!=null&&
695 classTypeSpec_AST.getFirstChild()!=null)?classTypeSpec_AST.getFirstChild():classTypeSpec_AST);
696 currentAST.advanceChildToEnd();
697 }
698 classTypeSpec_AST=(AST)currentAST.root;
699 returnAST=classTypeSpec_AST;
700 }
701 /***
702 * @param addImagNode
703 */
704 public final void builtInTypeSpec(boolean addImagNode) throws RecognitionException,
705 TokenStreamException
706 {
707 returnAST=null;
708 ASTPair currentAST=new ASTPair();
709 AST builtInTypeSpec_AST=null;
710 Token lb=null;
711 AST lb_AST=null;
712 builtInType();
713 astFactory.addASTChild(currentAST, returnAST);
714 {
715 _loop18:
716
717 do {
718 if(LA(1)==LBRACK) {
719 lb=LT(1);
720 lb_AST=astFactory.create(lb);
721 astFactory.makeASTRoot(currentAST, lb_AST);
722 match(LBRACK);
723 if(inputState.guessing==0) {
724 lb_AST.setType(ARRAY_DECLARATOR);
725 }
726 match(RBRACK);
727 } else {
728 break _loop18;
729 }
730 } while(true);
731
732 }
733 if(inputState.guessing==0) {
734 builtInTypeSpec_AST=(AST)currentAST.root;
735 if(addImagNode) {
736 builtInTypeSpec_AST=(AST)astFactory.make((new ASTArray(2)).add(astFactory.create(TYPE,
737 "TYPE")).add(builtInTypeSpec_AST));
738 }
739 currentAST.root=builtInTypeSpec_AST;
740 currentAST.child=((builtInTypeSpec_AST!=null&&
741 builtInTypeSpec_AST.getFirstChild()!=null)?builtInTypeSpec_AST.getFirstChild():builtInTypeSpec_AST);
742 currentAST.advanceChildToEnd();
743 }
744 builtInTypeSpec_AST=(AST)currentAST.root;
745 returnAST=builtInTypeSpec_AST;
746 }
747 /***
748 */
749 public final void builtInType() throws RecognitionException,
750 TokenStreamException
751 {
752 returnAST=null;
753 ASTPair currentAST=new ASTPair();
754 AST builtInType_AST=null;
755 switch(LA(1)) {
756 case LITERAL_void:
757
758 {
759 AST tmp20_AST=null;
760 tmp20_AST=astFactory.create(LT(1));
761 astFactory.addASTChild(currentAST, tmp20_AST);
762 match(LITERAL_void);
763 builtInType_AST=(AST)currentAST.root;
764 break;
765 }
766 case LITERAL_boolean:
767
768 {
769 AST tmp21_AST=null;
770 tmp21_AST=astFactory.create(LT(1));
771 astFactory.addASTChild(currentAST, tmp21_AST);
772 match(LITERAL_boolean);
773 builtInType_AST=(AST)currentAST.root;
774 break;
775 }
776 case LITERAL_byte:
777
778 {
779 AST tmp22_AST=null;
780 tmp22_AST=astFactory.create(LT(1));
781 astFactory.addASTChild(currentAST, tmp22_AST);
782 match(LITERAL_byte);
783 builtInType_AST=(AST)currentAST.root;
784 break;
785 }
786 case LITERAL_char:
787
788 {
789 AST tmp23_AST=null;
790 tmp23_AST=astFactory.create(LT(1));
791 astFactory.addASTChild(currentAST, tmp23_AST);
792 match(LITERAL_char);
793 builtInType_AST=(AST)currentAST.root;
794 break;
795 }
796 case LITERAL_short:
797
798 {
799 AST tmp24_AST=null;
800 tmp24_AST=astFactory.create(LT(1));
801 astFactory.addASTChild(currentAST, tmp24_AST);
802 match(LITERAL_short);
803 builtInType_AST=(AST)currentAST.root;
804 break;
805 }
806 case LITERAL_int:
807
808 {
809 AST tmp25_AST=null;
810 tmp25_AST=astFactory.create(LT(1));
811 astFactory.addASTChild(currentAST, tmp25_AST);
812 match(LITERAL_int);
813 builtInType_AST=(AST)currentAST.root;
814 break;
815 }
816 case LITERAL_float:
817
818 {
819 AST tmp26_AST=null;
820 tmp26_AST=astFactory.create(LT(1));
821 astFactory.addASTChild(currentAST, tmp26_AST);
822 match(LITERAL_float);
823 builtInType_AST=(AST)currentAST.root;
824 break;
825 }
826 case LITERAL_long:
827
828 {
829 AST tmp27_AST=null;
830 tmp27_AST=astFactory.create(LT(1));
831 astFactory.addASTChild(currentAST, tmp27_AST);
832 match(LITERAL_long);
833 builtInType_AST=(AST)currentAST.root;
834 break;
835 }
836 case LITERAL_double:
837
838 {
839 AST tmp28_AST=null;
840 tmp28_AST=astFactory.create(LT(1));
841 astFactory.addASTChild(currentAST, tmp28_AST);
842 match(LITERAL_double);
843 builtInType_AST=(AST)currentAST.root;
844 break;
845 }
846 default:
847
848 {
849 throw new NoViableAltException(LT(1), getFilename());
850 }
851 }
852 returnAST=builtInType_AST;
853 }
854 /***
855 */
856 public final void type() throws RecognitionException,
857 TokenStreamException
858 {
859 returnAST=null;
860 ASTPair currentAST=new ASTPair();
861 AST type_AST=null;
862 switch(LA(1)) {
863 case IDENT:
864
865 {
866 identifier();
867 astFactory.addASTChild(currentAST, returnAST);
868 type_AST=(AST)currentAST.root;
869 break;
870 }
871 case LITERAL_void:
872 case LITERAL_boolean:
873 case LITERAL_byte:
874 case LITERAL_char:
875 case LITERAL_short:
876 case LITERAL_int:
877 case LITERAL_float:
878 case LITERAL_long:
879 case LITERAL_double:
880
881 {
882 builtInType();
883 astFactory.addASTChild(currentAST, returnAST);
884 type_AST=(AST)currentAST.root;
885 break;
886 }
887 default:
888
889 {
890 throw new NoViableAltException(LT(1), getFilename());
891 }
892 }
893 returnAST=type_AST;
894 }
895 /***
896 */
897 public final void modifier() throws RecognitionException,
898 TokenStreamException
899 {
900 returnAST=null;
901 ASTPair currentAST=new ASTPair();
902 AST modifier_AST=null;
903 switch(LA(1)) {
904 case LITERAL_private:
905
906 {
907 AST tmp29_AST=null;
908 tmp29_AST=astFactory.create(LT(1));
909 astFactory.addASTChild(currentAST, tmp29_AST);
910 match(LITERAL_private);
911 modifier_AST=(AST)currentAST.root;
912 break;
913 }
914 case LITERAL_public:
915
916 {
917 AST tmp30_AST=null;
918 tmp30_AST=astFactory.create(LT(1));
919 astFactory.addASTChild(currentAST, tmp30_AST);
920 match(LITERAL_public);
921 modifier_AST=(AST)currentAST.root;
922 break;
923 }
924 case LITERAL_protected:
925
926 {
927 AST tmp31_AST=null;
928 tmp31_AST=astFactory.create(LT(1));
929 astFactory.addASTChild(currentAST, tmp31_AST);
930 match(LITERAL_protected);
931 modifier_AST=(AST)currentAST.root;
932 break;
933 }
934 case LITERAL_static:
935
936 {
937 AST tmp32_AST=null;
938 tmp32_AST=astFactory.create(LT(1));
939 astFactory.addASTChild(currentAST, tmp32_AST);
940 match(LITERAL_static);
941 modifier_AST=(AST)currentAST.root;
942 break;
943 }
944 case LITERAL_transient:
945
946 {
947 AST tmp33_AST=null;
948 tmp33_AST=astFactory.create(LT(1));
949 astFactory.addASTChild(currentAST, tmp33_AST);
950 match(LITERAL_transient);
951 modifier_AST=(AST)currentAST.root;
952 break;
953 }
954 case FINAL:
955
956 {
957 AST tmp34_AST=null;
958 tmp34_AST=astFactory.create(LT(1));
959 astFactory.addASTChild(currentAST, tmp34_AST);
960 match(FINAL);
961 modifier_AST=(AST)currentAST.root;
962 break;
963 }
964 case ABSTRACT:
965
966 {
967 AST tmp35_AST=null;
968 tmp35_AST=astFactory.create(LT(1));
969 astFactory.addASTChild(currentAST, tmp35_AST);
970 match(ABSTRACT);
971 modifier_AST=(AST)currentAST.root;
972 break;
973 }
974 case LITERAL_native:
975
976 {
977 AST tmp36_AST=null;
978 tmp36_AST=astFactory.create(LT(1));
979 astFactory.addASTChild(currentAST, tmp36_AST);
980 match(LITERAL_native);
981 modifier_AST=(AST)currentAST.root;
982 break;
983 }
984 case LITERAL_threadsafe:
985
986 {
987 AST tmp37_AST=null;
988 tmp37_AST=astFactory.create(LT(1));
989 astFactory.addASTChild(currentAST, tmp37_AST);
990 match(LITERAL_threadsafe);
991 modifier_AST=(AST)currentAST.root;
992 break;
993 }
994 case LITERAL_synchronized:
995
996 {
997 AST tmp38_AST=null;
998 tmp38_AST=astFactory.create(LT(1));
999 astFactory.addASTChild(currentAST, tmp38_AST);
1000 match(LITERAL_synchronized);
1001 modifier_AST=(AST)currentAST.root;
1002 break;
1003 }
1004 case LITERAL_volatile:
1005
1006 {
1007 AST tmp39_AST=null;
1008 tmp39_AST=astFactory.create(LT(1));
1009 astFactory.addASTChild(currentAST, tmp39_AST);
1010 match(LITERAL_volatile);
1011 modifier_AST=(AST)currentAST.root;
1012 break;
1013 }
1014 case STRICTFP:
1015
1016 {
1017 AST tmp40_AST=null;
1018 tmp40_AST=astFactory.create(LT(1));
1019 astFactory.addASTChild(currentAST, tmp40_AST);
1020 match(STRICTFP);
1021 modifier_AST=(AST)currentAST.root;
1022 break;
1023 }
1024 default:
1025
1026 {
1027 throw new NoViableAltException(LT(1), getFilename());
1028 }
1029 }
1030 returnAST=modifier_AST;
1031 }
1032 /***
1033 */
1034 public final void superClassClause() throws RecognitionException,
1035 TokenStreamException
1036 {
1037 returnAST=null;
1038 ASTPair currentAST=new ASTPair();
1039 AST superClassClause_AST=null;
1040 AST id_AST=null;
1041 {
1042 switch(LA(1)) {
1043 case LITERAL_extends:
1044
1045 {
1046 match(LITERAL_extends);
1047 identifier();
1048 id_AST=(AST)returnAST;
1049 break;
1050 }
1051 case LCURLY:
1052 case LITERAL_implements:
1053
1054 {
1055 break;
1056 }
1057 default:
1058
1059 {
1060 throw new NoViableAltException(LT(1), getFilename());
1061 }
1062 }
1063 }
1064 if(inputState.guessing==0) {
1065 superClassClause_AST=(AST)currentAST.root;
1066 superClassClause_AST=(AST)astFactory.make((new ASTArray(2)).add(astFactory.create(EXTENDS_CLAUSE,
1067 "EXTENDS_CLAUSE")).add(id_AST));
1068 currentAST.root=superClassClause_AST;
1069 currentAST.child=((superClassClause_AST!=null&&
1070 superClassClause_AST.getFirstChild()!=null)?superClassClause_AST.getFirstChild():superClassClause_AST);
1071 currentAST.advanceChildToEnd();
1072 }
1073 returnAST=superClassClause_AST;
1074 }
1075 /***
1076 */
1077 public final void implementsClause() throws RecognitionException,
1078 TokenStreamException
1079 {
1080 returnAST=null;
1081 ASTPair currentAST=new ASTPair();
1082 AST implementsClause_AST=null;
1083 Token i=null;
1084 AST i_AST=null;
1085 {
1086 switch(LA(1)) {
1087 case LITERAL_implements:
1088
1089 {
1090 i=LT(1);
1091 i_AST=astFactory.create(i);
1092 match(LITERAL_implements);
1093 identifier();
1094 astFactory.addASTChild(currentAST, returnAST);
1095 {
1096 _loop46:
1097
1098 do {
1099 if(LA(1)==COMMA) {
1100 match(COMMA);
1101 identifier();
1102 astFactory.addASTChild(currentAST,
1103 returnAST);
1104 } else {
1105 break _loop46;
1106 }
1107 } while(true);
1108
1109 }
1110 break;
1111 }
1112 case LCURLY:
1113
1114 {
1115 break;
1116 }
1117 default:
1118
1119 {
1120 throw new NoViableAltException(LT(1), getFilename());
1121 }
1122 }
1123 }
1124 if(inputState.guessing==0) {
1125 implementsClause_AST=(AST)currentAST.root;
1126 implementsClause_AST=(AST)astFactory.make((new ASTArray(2)).add(astFactory.create(IMPLEMENTS_CLAUSE,
1127 "IMPLEMENTS_CLAUSE")).add(implementsClause_AST));
1128 currentAST.root=implementsClause_AST;
1129 currentAST.child=((implementsClause_AST!=null&&
1130 implementsClause_AST.getFirstChild()!=null)?implementsClause_AST.getFirstChild():implementsClause_AST);
1131 currentAST.advanceChildToEnd();
1132 }
1133 implementsClause_AST=(AST)currentAST.root;
1134 returnAST=implementsClause_AST;
1135 }
1136 /***
1137 */
1138 public final void classBlock() throws RecognitionException,
1139 TokenStreamException
1140 {
1141 returnAST=null;
1142 ASTPair currentAST=new ASTPair();
1143 AST classBlock_AST=null;
1144 match(LCURLY);
1145 {
1146 _loop38:
1147
1148 do {
1149 switch(LA(1)) {
1150 case FINAL:
1151 case ABSTRACT:
1152 case STRICTFP:
1153 case LITERAL_void:
1154 case LITERAL_boolean:
1155 case LITERAL_byte:
1156 case LITERAL_char:
1157 case LITERAL_short:
1158 case LITERAL_int:
1159 case LITERAL_float:
1160 case LITERAL_long:
1161 case LITERAL_double:
1162 case IDENT:
1163 case LITERAL_private:
1164 case LITERAL_public:
1165 case LITERAL_protected:
1166 case LITERAL_static:
1167 case LITERAL_transient:
1168 case LITERAL_native:
1169 case LITERAL_threadsafe:
1170 case LITERAL_synchronized:
1171 case LITERAL_volatile:
1172 case LITERAL_class:
1173 case LITERAL_interface:
1174 case LCURLY:
1175
1176 {
1177 field();
1178 astFactory.addASTChild(currentAST, returnAST);
1179 break;
1180 }
1181 case SEMI:
1182
1183 {
1184 match(SEMI);
1185 break;
1186 }
1187 default:
1188
1189 {
1190 break _loop38;
1191 }
1192 }
1193 } while(true);
1194
1195 }
1196 match(RCURLY);
1197 if(inputState.guessing==0) {
1198 classBlock_AST=(AST)currentAST.root;
1199 classBlock_AST=(AST)astFactory.make((new ASTArray(2)).add(astFactory.create(OBJBLOCK,
1200 "OBJBLOCK")).add(classBlock_AST));
1201 currentAST.root=classBlock_AST;
1202 currentAST.child=((classBlock_AST!=null&&
1203 classBlock_AST.getFirstChild()!=null)?classBlock_AST.getFirstChild():classBlock_AST);
1204 currentAST.advanceChildToEnd();
1205 }
1206 classBlock_AST=(AST)currentAST.root;
1207 returnAST=classBlock_AST;
1208 }
1209 /***
1210 */
1211 public final void interfaceExtends() throws RecognitionException,
1212 TokenStreamException
1213 {
1214 returnAST=null;
1215 ASTPair currentAST=new ASTPair();
1216 AST interfaceExtends_AST=null;
1217 Token e=null;
1218 AST e_AST=null;
1219 {
1220 switch(LA(1)) {
1221 case LITERAL_extends:
1222
1223 {
1224 e=LT(1);
1225 e_AST=astFactory.create(e);
1226 match(LITERAL_extends);
1227 identifier();
1228 astFactory.addASTChild(currentAST, returnAST);
1229 {
1230 _loop42:
1231
1232 do {
1233 if(LA(1)==COMMA) {
1234 match(COMMA);
1235 identifier();
1236 astFactory.addASTChild(currentAST,
1237 returnAST);
1238 } else {
1239 break _loop42;
1240 }
1241 } while(true);
1242
1243 }
1244 break;
1245 }
1246 case LCURLY:
1247
1248 {
1249 break;
1250 }
1251 default:
1252
1253 {
1254 throw new NoViableAltException(LT(1), getFilename());
1255 }
1256 }
1257 }
1258 if(inputState.guessing==0) {
1259 interfaceExtends_AST=(AST)currentAST.root;
1260 interfaceExtends_AST=(AST)astFactory.make((new ASTArray(2)).add(astFactory.create(EXTENDS_CLAUSE,
1261 "EXTENDS_CLAUSE")).add(interfaceExtends_AST));
1262 currentAST.root=interfaceExtends_AST;
1263 currentAST.child=((interfaceExtends_AST!=null&&
1264 interfaceExtends_AST.getFirstChild()!=null)?interfaceExtends_AST.getFirstChild():interfaceExtends_AST);
1265 currentAST.advanceChildToEnd();
1266 }
1267 interfaceExtends_AST=(AST)currentAST.root;
1268 returnAST=interfaceExtends_AST;
1269 }
1270 /***
1271 */
1272 public final void field() throws RecognitionException,
1273 TokenStreamException
1274 {
1275 returnAST=null;
1276 ASTPair currentAST=new ASTPair();
1277 AST field_AST=null;
1278 AST mods_AST=null;
1279 AST h_AST=null;
1280 AST s_AST=null;
1281 AST cd_AST=null;
1282 AST id_AST=null;
1283 AST t_AST=null;
1284 AST param_AST=null;
1285 AST rt_AST=null;
1286 AST tc_AST=null;
1287 AST s2_AST=null;
1288 AST v_AST=null;
1289 AST s3_AST=null;
1290 AST s4_AST=null;
1291 if(_tokenSet_4.member(LA(1))&&_tokenSet_5.member(LA(2))) {
1292 modifiers();
1293 mods_AST=(AST)returnAST;
1294 {
1295 switch(LA(1)) {
1296 case LITERAL_class:
1297
1298 {
1299 classDefinition(mods_AST);
1300 cd_AST=(AST)returnAST;
1301 if(inputState.guessing==0) {
1302 field_AST=(AST)currentAST.root;
1303 field_AST=cd_AST;
1304 currentAST.root=field_AST;
1305 currentAST.child=((field_AST!=null&&
1306 field_AST.getFirstChild()!=null)?field_AST.getFirstChild():field_AST);
1307 currentAST.advanceChildToEnd();
1308 }
1309 break;
1310 }
1311 case LITERAL_interface:
1312
1313 {
1314 interfaceDefinition(mods_AST);
1315 id_AST=(AST)returnAST;
1316 if(inputState.guessing==0) {
1317 field_AST=(AST)currentAST.root;
1318 field_AST=id_AST;
1319 currentAST.root=field_AST;
1320 currentAST.child=((field_AST!=null&&
1321 field_AST.getFirstChild()!=null)?field_AST.getFirstChild():field_AST);
1322 currentAST.advanceChildToEnd();
1323 }
1324 break;
1325 }
1326 default:
1327
1328 if(LA(1)==IDENT&&LA(2)==LPAREN) {
1329 ctorHead();
1330 h_AST=(AST)returnAST;
1331 constructorBody();
1332 s_AST=(AST)returnAST;
1333 if(inputState.guessing==0) {
1334 field_AST=(AST)currentAST.root;
1335 field_AST=(AST)astFactory.make((new ASTArray(4)).add(astFactory.create(CTOR_DEF,
1336 "CTOR_DEF")).add(mods_AST).add(h_AST).add(s_AST));
1337 currentAST.root=field_AST;
1338 currentAST.child=((field_AST!=null&&
1339 field_AST.getFirstChild()!=null)?field_AST.getFirstChild():field_AST);
1340 currentAST.advanceChildToEnd();
1341 }
1342 } else if(LA(1)>=LITERAL_void&&
1343 LA(1)<=IDENT&&_tokenSet_6.member(LA(2))) {
1344 typeSpec(false);
1345 t_AST=(AST)returnAST;
1346 {
1347 if(LA(1)==IDENT&&LA(2)==LPAREN) {
1348 AST tmp47_AST=null;
1349 tmp47_AST=astFactory.create(LT(1));
1350 match(IDENT);
1351 match(LPAREN);
1352 parameterDeclarationList();
1353 param_AST=(AST)returnAST;
1354 match(RPAREN);
1355 declaratorBrackets(t_AST);
1356 rt_AST=(AST)returnAST;
1357 {
1358 switch(LA(1)) {
1359 case LITERAL_throws:
1360
1361 {
1362 throwsClause();
1363 tc_AST=(AST)returnAST;
1364 break;
1365 }
1366 case SEMI:
1367 case LCURLY:
1368
1369 {
1370 break;
1371 }
1372 default:
1373
1374 {
1375 throw new NoViableAltException(LT(1),
1376 getFilename());
1377 }
1378 }
1379 }
1380 {
1381 switch(LA(1)) {
1382 case LCURLY:
1383
1384 {
1385 compoundStatement();
1386 s2_AST=(AST)returnAST;
1387 break;
1388 }
1389 case SEMI:
1390
1391 {
1392 AST tmp50_AST=null;
1393 tmp50_AST=astFactory.create(LT(1));
1394 match(SEMI);
1395 break;
1396 }
1397 default:
1398
1399 {
1400 throw new NoViableAltException(LT(1),
1401 getFilename());
1402 }
1403 }
1404 }
1405 if(inputState.guessing==0) {
1406 field_AST=(AST)currentAST.root;
1407 field_AST=(AST)astFactory.make((new ASTArray(7)).add(astFactory.create(METHOD_DEF,
1408 "METHOD_DEF")).add(mods_AST).add((AST)astFactory.make((new ASTArray(2)).add(astFactory.create(TYPE,
1409 "TYPE")).add(rt_AST))).add(tmp47_AST).add(param_AST).add(tc_AST).add(s2_AST));
1410 currentAST.root=field_AST;
1411 currentAST.child=((field_AST!=null&&
1412 field_AST.getFirstChild()!=null)?field_AST.getFirstChild():field_AST);
1413 currentAST.advanceChildToEnd();
1414 }
1415 } else if(LA(1)==IDENT&&_tokenSet_7.member(LA(2))) {
1416 variableDefinitions(mods_AST, t_AST);
1417 v_AST=(AST)returnAST;
1418 AST tmp51_AST=null;
1419 tmp51_AST=astFactory.create(LT(1));
1420 match(SEMI);
1421 if(inputState.guessing==0) {
1422 field_AST=(AST)currentAST.root;
1423 field_AST=v_AST;
1424 currentAST.root=field_AST;
1425 currentAST.child=((field_AST!=null&&
1426 field_AST.getFirstChild()!=null)?field_AST.getFirstChild():field_AST);
1427 currentAST.advanceChildToEnd();
1428 }
1429 } else {
1430 throw new NoViableAltException(LT(1),
1431 getFilename());
1432 }
1433 }
1434 } else {
1435 throw new NoViableAltException(LT(1),
1436 getFilename());
1437 }
1438 }
1439 }
1440 } else if(LA(1)==LITERAL_static&&LA(2)==LCURLY) {
1441 match(LITERAL_static);
1442 compoundStatement();
1443 s3_AST=(AST)returnAST;
1444 if(inputState.guessing==0) {
1445 field_AST=(AST)currentAST.root;
1446 field_AST=(AST)astFactory.make((new ASTArray(2)).add(astFactory.create(STATIC_INIT,
1447 "STATIC_INIT")).add(s3_AST));
1448 currentAST.root=field_AST;
1449 currentAST.child=((field_AST!=null&&
1450 field_AST.getFirstChild()!=null)?field_AST.getFirstChild():field_AST);
1451 currentAST.advanceChildToEnd();
1452 }
1453 } else if(LA(1)==LCURLY) {
1454 compoundStatement();
1455 s4_AST=(AST)returnAST;
1456 if(inputState.guessing==0) {
1457 field_AST=(AST)currentAST.root;
1458 field_AST=(AST)astFactory.make((new ASTArray(2)).add(astFactory.create(INSTANCE_INIT,
1459 "INSTANCE_INIT")).add(s4_AST));
1460 currentAST.root=field_AST;
1461 currentAST.child=((field_AST!=null&&
1462 field_AST.getFirstChild()!=null)?field_AST.getFirstChild():field_AST);
1463 currentAST.advanceChildToEnd();
1464 }
1465 } else {
1466 throw new NoViableAltException(LT(1), getFilename());
1467 }
1468 returnAST=field_AST;
1469 }
1470 /***
1471 */
1472 public final void ctorHead() throws RecognitionException,
1473 TokenStreamException
1474 {
1475 returnAST=null;
1476 ASTPair currentAST=new ASTPair();
1477 AST ctorHead_AST=null;
1478 AST tmp53_AST=null;
1479 tmp53_AST=astFactory.create(LT(1));
1480 astFactory.addASTChild(currentAST, tmp53_AST);
1481 match(IDENT);
1482 match(LPAREN);
1483 parameterDeclarationList();
1484 astFactory.addASTChild(currentAST, returnAST);
1485 match(RPAREN);
1486 {
1487 switch(LA(1)) {
1488 case LITERAL_throws:
1489
1490 {
1491 throwsClause();
1492 astFactory.addASTChild(currentAST, returnAST);
1493 break;
1494 }
1495 case LCURLY:
1496
1497 {
1498 break;
1499 }
1500 default:
1501
1502 {
1503 throw new NoViableAltException(LT(1), getFilename());
1504 }
1505 }
1506 }
1507 ctorHead_AST=(AST)currentAST.root;
1508 returnAST=ctorHead_AST;
1509 }
1510 /***
1511 */
1512 public final void constructorBody() throws RecognitionException,
1513 TokenStreamException
1514 {
1515 returnAST=null;
1516 ASTPair currentAST=new ASTPair();
1517 AST constructorBody_AST=null;
1518 Token lc=null;
1519 AST lc_AST=null;
1520 lc=LT(1);
1521 lc_AST=astFactory.create(lc);
1522 astFactory.makeASTRoot(currentAST, lc_AST);
1523 match(LCURLY);
1524 if(inputState.guessing==0) {
1525 lc_AST.setType(SLIST);
1526 }
1527 {
1528 if((LA(1)==LITERAL_this||LA(1)==LITERAL_super)&&
1529 LA(2)==LPAREN) {
1530 explicitConstructorInvocation();
1531 astFactory.addASTChild(currentAST, returnAST);
1532 } else if(_tokenSet_8.member(LA(1))&&_tokenSet_9.member(LA(2))) {
1533 } else {
1534 throw new NoViableAltException(LT(1), getFilename());
1535 }
1536 }
1537 {
1538 _loop55:
1539
1540 do {
1541 if(_tokenSet_10.member(LA(1))) {
1542 statement();
1543 astFactory.addASTChild(currentAST, returnAST);
1544 } else {
1545 break _loop55;
1546 }
1547 } while(true);
1548
1549 }
1550 match(RCURLY);
1551 constructorBody_AST=(AST)currentAST.root;
1552 returnAST=constructorBody_AST;
1553 }
1554 /***
1555 */
1556 public final void parameterDeclarationList() throws RecognitionException,
1557 TokenStreamException
1558 {
1559 returnAST=null;
1560 ASTPair currentAST=new ASTPair();
1561 AST parameterDeclarationList_AST=null;
1562 {
1563 switch(LA(1)) {
1564 case FINAL:
1565 case LITERAL_void:
1566 case LITERAL_boolean:
1567 case LITERAL_byte:
1568 case LITERAL_char:
1569 case LITERAL_short:
1570 case LITERAL_int:
1571 case LITERAL_float:
1572 case LITERAL_long:
1573 case LITERAL_double:
1574 case IDENT:
1575
1576 {
1577 parameterDeclaration();
1578 astFactory.addASTChild(currentAST, returnAST);
1579 {
1580 _loop80:
1581
1582 do {
1583 if(LA(1)==COMMA) {
1584 match(COMMA);
1585 parameterDeclaration();
1586 astFactory.addASTChild(currentAST,
1587 returnAST);
1588 } else {
1589 break _loop80;
1590 }
1591 } while(true);
1592
1593 }
1594 break;
1595 }
1596 case RPAREN:
1597
1598 {
1599 break;
1600 }
1601 default:
1602
1603 {
1604 throw new NoViableAltException(LT(1), getFilename());
1605 }
1606 }
1607 }
1608 if(inputState.guessing==0) {
1609 parameterDeclarationList_AST=(AST)currentAST.root;
1610 parameterDeclarationList_AST=(AST)astFactory.make((new ASTArray(2)).add(astFactory.create(PARAMETERS,
1611 "PARAMETERS")).add(parameterDeclarationList_AST));
1612 currentAST.root=parameterDeclarationList_AST;
1613 currentAST.child=((parameterDeclarationList_AST!=null&&
1614 parameterDeclarationList_AST.getFirstChild()!=null)?parameterDeclarationList_AST.getFirstChild():parameterDeclarationList_AST);
1615 currentAST.advanceChildToEnd();
1616 }
1617 parameterDeclarationList_AST=(AST)currentAST.root;
1618 returnAST=parameterDeclarationList_AST;
1619 }
1620 /***
1621 * @param typ
1622 */
1623 public final void declaratorBrackets(AST typ) throws RecognitionException,
1624 TokenStreamException
1625 {
1626 returnAST=null;
1627 ASTPair currentAST=new ASTPair();
1628 AST declaratorBrackets_AST=null;
1629 Token lb=null;
1630 AST lb_AST=null;
1631 if(inputState.guessing==0) {
1632 declaratorBrackets_AST=(AST)currentAST.root;
1633 declaratorBrackets_AST=typ;
1634 currentAST.root=declaratorBrackets_AST;
1635 currentAST.child=((declaratorBrackets_AST!=null&&
1636 declaratorBrackets_AST.getFirstChild()!=null)?declaratorBrackets_AST.getFirstChild():declaratorBrackets_AST);
1637 currentAST.advanceChildToEnd();
1638 }
1639 {
1640 _loop63:
1641
1642 do {
1643 if(LA(1)==LBRACK) {
1644 lb=LT(1);
1645 lb_AST=astFactory.create(lb);
1646 astFactory.makeASTRoot(currentAST, lb_AST);
1647 match(LBRACK);
1648 if(inputState.guessing==0) {
1649 lb_AST.setType(ARRAY_DECLARATOR);
1650 }
1651 match(RBRACK);
1652 } else {
1653 break _loop63;
1654 }
1655 } while(true);
1656
1657 }
1658 declaratorBrackets_AST=(AST)currentAST.root;
1659 returnAST=declaratorBrackets_AST;
1660 }
1661 /***
1662 */
1663 public final void throwsClause() throws RecognitionException,
1664 TokenStreamException
1665 {
1666 returnAST=null;
1667 ASTPair currentAST=new ASTPair();
1668 AST throwsClause_AST=null;
1669 Token tc=null;
1670 AST tc_AST=null;
1671 tc=LT(1);
1672 tc_AST=astFactory.create(tc);
1673 astFactory.makeASTRoot(currentAST, tc_AST);
1674 match(LITERAL_throws);
1675 identifier();
1676 astFactory.addASTChild(currentAST, returnAST);
1677 {
1678 _loop76:
1679
1680 do {
1681 if(LA(1)==COMMA) {
1682 match(COMMA);
1683 identifier();
1684 astFactory.addASTChild(currentAST, returnAST);
1685 } else {
1686 break _loop76;
1687 }
1688 } while(true);
1689
1690 }
1691 if(inputState.guessing==0) {
1692 tc_AST.setType(THROWS_CLAUSE);
1693 }
1694 throwsClause_AST=(AST)currentAST.root;
1695 returnAST=throwsClause_AST;
1696 }
1697 /***
1698 */
1699 public final void compoundStatement() throws RecognitionException,
1700 TokenStreamException
1701 {
1702 returnAST=null;
1703 ASTPair currentAST=new ASTPair();
1704 AST compoundStatement_AST=null;
1705 Token lc=null;
1706 AST lc_AST=null;
1707 lc=LT(1);
1708 lc_AST=astFactory.create(lc);
1709 astFactory.makeASTRoot(currentAST, lc_AST);
1710 match(LCURLY);
1711 if(inputState.guessing==0) {
1712 lc_AST.setType(SLIST);
1713 }
1714 {
1715 _loop86:
1716
1717 do {
1718 if(_tokenSet_10.member(LA(1))) {
1719 statement();
1720 astFactory.addASTChild(currentAST, returnAST);
1721 } else {
1722 break _loop86;
1723 }
1724 } while(true);
1725
1726 }
1727 match(RCURLY);
1728 compoundStatement_AST=(AST)currentAST.root;
1729 returnAST=compoundStatement_AST;
1730 }
1731 /***
1732 * Catch obvious constructor calls, but not the expr.super(...) calls
1733 */
1734 public final void explicitConstructorInvocation() throws RecognitionException,
1735 TokenStreamException
1736 {
1737 returnAST=null;
1738 ASTPair currentAST=new ASTPair();
1739 AST explicitConstructorInvocation_AST=null;
1740 Token lp1=null;
1741 AST lp1_AST=null;
1742 Token lp2=null;
1743 AST lp2_AST=null;
1744 switch(LA(1)) {
1745 case LITERAL_this:
1746
1747 {
1748 match(LITERAL_this);
1749 lp1=LT(1);
1750 lp1_AST=astFactory.create(lp1);
1751 astFactory.makeASTRoot(currentAST, lp1_AST);
1752 match(LPAREN);
1753 argList();
1754 astFactory.addASTChild(currentAST, returnAST);
1755 match(RPAREN);
1756 match(SEMI);
1757 if(inputState.guessing==0) {
1758 lp1_AST.setType(CTOR_CALL);
1759 }
1760 explicitConstructorInvocation_AST=(AST)currentAST.root;
1761 break;
1762 }
1763 case LITERAL_super:
1764
1765 {
1766 match(LITERAL_super);
1767 lp2=LT(1);
1768 lp2_AST=astFactory.create(lp2);
1769 astFactory.makeASTRoot(currentAST, lp2_AST);
1770 match(LPAREN);
1771 argList();
1772 astFactory.addASTChild(currentAST, returnAST);
1773 match(RPAREN);
1774 match(SEMI);
1775 if(inputState.guessing==0) {
1776 lp2_AST.setType(SUPER_CTOR_CALL);
1777 }
1778 explicitConstructorInvocation_AST=(AST)currentAST.root;
1779 break;
1780 }
1781 default:
1782
1783 {
1784 throw new NoViableAltException(LT(1), getFilename());
1785 }
1786 }
1787 returnAST=explicitConstructorInvocation_AST;
1788 }
1789 /***
1790 */
1791 public final void statement() throws RecognitionException,
1792 TokenStreamException
1793 {
1794 returnAST=null;
1795 ASTPair currentAST=new ASTPair();
1796 AST statement_AST=null;
1797 AST m_AST=null;
1798 Token c=null;
1799 AST c_AST=null;
1800 Token i=null;
1801 AST i_AST=null;
1802 Token f=null;
1803 AST f_AST=null;
1804 Token w=null;
1805 AST w_AST=null;
1806 Token d=null;
1807 AST d_AST=null;
1808 Token b=null;
1809 AST b_AST=null;
1810 Token cn=null;
1811 AST cn_AST=null;
1812 Token r=null;
1813 AST r_AST=null;
1814 Token sw=null;
1815 AST sw_AST=null;
1816 Token t=null;
1817 AST t_AST=null;
1818 Token sy=null;
1819 AST sy_AST=null;
1820 Token s=null;
1821 AST s_AST=null;
1822 switch(LA(1)) {
1823 case LCURLY:
1824
1825 {
1826 compoundStatement();
1827 astFactory.addASTChild(currentAST, returnAST);
1828 statement_AST=(AST)currentAST.root;
1829 break;
1830 }
1831 case LITERAL_if:
1832
1833 {
1834 i=LT(1);
1835 i_AST=astFactory.create(i);
1836 astFactory.makeASTRoot(currentAST, i_AST);
1837 match(LITERAL_if);
1838 match(LPAREN);
1839 expression();
1840 astFactory.addASTChild(currentAST, returnAST);
1841 match(RPAREN);
1842 statement();
1843 astFactory.addASTChild(currentAST, returnAST);
1844 {
1845 if(LA(1)==LITERAL_else&&_tokenSet_10.member(LA(2))) {
1846 match(LITERAL_else);
1847 statement();
1848 astFactory.addASTChild(currentAST, returnAST);
1849 } else if(_tokenSet_11.member(LA(1))&&_tokenSet_12.member(LA(2))) {
1850 } else {
1851 throw new NoViableAltException(LT(1),
1852 getFilename());
1853 }
1854 }
1855 if(inputState.guessing==0) {
1856 i_AST.setType(IF);
1857 }
1858 statement_AST=(AST)currentAST.root;
1859 break;
1860 }
1861 case LITERAL_for:
1862
1863 {
1864 f=LT(1);
1865 f_AST=astFactory.create(f);
1866 astFactory.makeASTRoot(currentAST, f_AST);
1867 match(LITERAL_for);
1868 match(LPAREN);
1869 forInit();
1870 astFactory.addASTChild(currentAST, returnAST);
1871 match(SEMI);
1872 forCond();
1873 astFactory.addASTChild(currentAST, returnAST);
1874 match(SEMI);
1875 forIter();
1876 astFactory.addASTChild(currentAST, returnAST);
1877 match(RPAREN);
1878 statement();
1879 astFactory.addASTChild(currentAST, returnAST);
1880 if(inputState.guessing==0) {
1881 f_AST.setType(FOR);
1882 }
1883 statement_AST=(AST)currentAST.root;
1884 break;
1885 }
1886 case LITERAL_while:
1887
1888 {
1889 w=LT(1);
1890 w_AST=astFactory.create(w);
1891 astFactory.makeASTRoot(currentAST, w_AST);
1892 match(LITERAL_while);
1893 match(LPAREN);
1894 expression();
1895 astFactory.addASTChild(currentAST, returnAST);
1896 match(RPAREN);
1897 statement();
1898 astFactory.addASTChild(currentAST, returnAST);
1899 if(inputState.guessing==0) {
1900 w_AST.setType(WHILE);
1901 }
1902 statement_AST=(AST)currentAST.root;
1903 break;
1904 }
1905 case LITERAL_do:
1906
1907 {
1908 d=LT(1);
1909 d_AST=astFactory.create(d);
1910 astFactory.makeASTRoot(currentAST, d_AST);
1911 match(LITERAL_do);
1912 statement();
1913 astFactory.addASTChild(currentAST, returnAST);
1914 match(LITERAL_while);
1915 match(LPAREN);
1916 expression();
1917 astFactory.addASTChild(currentAST, returnAST);
1918 match(RPAREN);
1919 match(SEMI);
1920 if(inputState.guessing==0) {
1921 d_AST.setType(DO);
1922 }
1923 statement_AST=(AST)currentAST.root;
1924 break;
1925 }
1926 case LITERAL_break:
1927
1928 {
1929 b=LT(1);
1930 b_AST=astFactory.create(b);
1931 astFactory.makeASTRoot(currentAST, b_AST);
1932 match(LITERAL_break);
1933 {
1934 switch(LA(1)) {
1935 case IDENT:
1936
1937 {
1938 AST tmp80_AST=null;
1939 tmp80_AST=astFactory.create(LT(1));
1940 astFactory.addASTChild(currentAST, tmp80_AST);
1941 match(IDENT);
1942 break;
1943 }
1944 case SEMI:
1945
1946 {
1947 break;
1948 }
1949 default:
1950
1951 {
1952 throw new NoViableAltException(LT(1),
1953 getFilename());
1954 }
1955 }
1956 }
1957 match(SEMI);
1958 if(inputState.guessing==0) {
1959 b_AST.setType(BREAK);
1960 }
1961 statement_AST=(AST)currentAST.root;
1962 break;
1963 }
1964 case LITERAL_continue:
1965
1966 {
1967 cn=LT(1);
1968 cn_AST=astFactory.create(cn);
1969 astFactory.makeASTRoot(currentAST, cn_AST);
1970 match(LITERAL_continue);
1971 {
1972 switch(LA(1)) {
1973 case IDENT:
1974
1975 {
1976 AST tmp82_AST=null;
1977 tmp82_AST=astFactory.create(LT(1));
1978 astFactory.addASTChild(currentAST, tmp82_AST);
1979 match(IDENT);
1980 break;
1981 }
1982 case SEMI:
1983
1984 {
1985 break;
1986 }
1987 default:
1988
1989 {
1990 throw new NoViableAltException(LT(1),
1991 getFilename());
1992 }
1993 }
1994 }
1995 match(SEMI);
1996 if(inputState.guessing==0) {
1997 cn_AST.setType(CONTINUE);
1998 }
1999 statement_AST=(AST)currentAST.root;
2000 break;
2001 }
2002 case LITERAL_return:
2003
2004 {
2005 r=LT(1);
2006 r_AST=astFactory.create(r);
2007 astFactory.makeASTRoot(currentAST, r_AST);
2008 match(LITERAL_return);
2009 {
2010 switch(LA(1)) {
2011 case LITERAL_void:
2012 case LITERAL_boolean:
2013 case LITERAL_byte:
2014 case LITERAL_char:
2015 case LITERAL_short:
2016 case LITERAL_int:
2017 case LITERAL_float:
2018 case LITERAL_long:
2019 case LITERAL_double:
2020 case IDENT:
2021 case LPAREN:
2022 case LITERAL_this:
2023 case LITERAL_super:
2024 case PLUS:
2025 case MINUS:
2026 case INC:
2027 case DEC:
2028 case BNOT:
2029 case LNOT:
2030 case LITERAL_true:
2031 case LITERAL_false:
2032 case LITERAL_null:
2033 case LITERAL_new:
2034 case NUM_INT:
2035 case CHAR_LITERAL:
2036 case STRING_LITERAL:
2037 case NUM_FLOAT:
2038 case NUM_LONG:
2039 case NUM_DOUBLE:
2040
2041 {
2042 expression();
2043 astFactory.addASTChild(currentAST, returnAST);
2044 break;
2045 }
2046 case SEMI:
2047
2048 {
2049 break;
2050 }
2051 default:
2052
2053 {
2054 throw new NoViableAltException(LT(1),
2055 getFilename());
2056 }
2057 }
2058 }
2059 match(SEMI);
2060 if(inputState.guessing==0) {
2061 r_AST.setType(RETURN);
2062 }
2063 statement_AST=(AST)currentAST.root;
2064 break;
2065 }
2066 case LITERAL_switch:
2067
2068 {
2069 sw=LT(1);
2070 sw_AST=astFactory.create(sw);
2071 astFactory.makeASTRoot(currentAST, sw_AST);
2072 match(LITERAL_switch);
2073 match(LPAREN);
2074 expression();
2075 astFactory.addASTChild(currentAST, returnAST);
2076 match(RPAREN);
2077 match(LCURLY);
2078 {
2079 _loop95:
2080
2081 do {
2082 if(LA(1)==LITERAL_case||
2083 LA(1)==LITERAL_default) {
2084 casesGroup();
2085 astFactory.addASTChild(currentAST,
2086 returnAST);
2087 } else {
2088 break _loop95;
2089 }
2090 } while(true);
2091
2092 }
2093 match(RCURLY);
2094 if(inputState.guessing==0) {
2095 sw_AST.setType(SWITCH);
2096 }
2097 statement_AST=(AST)currentAST.root;
2098 break;
2099 }
2100 case LITERAL_try:
2101
2102 {
2103 tryBlock();
2104 astFactory.addASTChild(currentAST, returnAST);
2105 statement_AST=(AST)currentAST.root;
2106 break;
2107 }
2108 case LITERAL_throw:
2109
2110 {
2111 t=LT(1);
2112 t_AST=astFactory.create(t);
2113 astFactory.makeASTRoot(currentAST, t_AST);
2114 match(LITERAL_throw);
2115 expression();
2116 astFactory.addASTChild(currentAST, returnAST);
2117 match(SEMI);
2118 if(inputState.guessing==0) {
2119 t_AST.setType(THROW);
2120 }
2121 statement_AST=(AST)currentAST.root;
2122 break;
2123 }
2124 case SEMI:
2125
2126 {
2127 s=LT(1);
2128 s_AST=astFactory.create(s);
2129 astFactory.addASTChild(currentAST, s_AST);
2130 match(SEMI);
2131 if(inputState.guessing==0) {
2132 s_AST.setType(EMPTY_STAT);
2133 }
2134 statement_AST=(AST)currentAST.root;
2135 break;
2136 }
2137 default:
2138
2139 boolean synPredMatched89=false;
2140 if(_tokenSet_13.member(LA(1))&&_tokenSet_14.member(LA(2))) {
2141 int _m89=mark();
2142 synPredMatched89=true;
2143 inputState.guessing++;
2144 try{
2145 {
2146 declaration();
2147 }
2148 }catch (RecognitionException pe) {
2149 synPredMatched89=false;
2150 }
2151 rewind(_m89);
2152 inputState.guessing--;
2153 }
2154 if(synPredMatched89) {
2155 declaration();
2156 astFactory.addASTChild(currentAST, returnAST);
2157 match(SEMI);
2158 statement_AST=(AST)currentAST.root;
2159 } else if(_tokenSet_15.member(LA(1))&&_tokenSet_16.member(LA(2))) {
2160 expression();
2161 astFactory.addASTChild(currentAST, returnAST);
2162 match(SEMI);
2163 statement_AST=(AST)currentAST.root;
2164 } else if(_tokenSet_17.member(LA(1))&&_tokenSet_18.member(LA(2))) {
2165 modifiers();
2166 m_AST=(AST)returnAST;
2167 classDefinition(m_AST);
2168 astFactory.addASTChild(currentAST, returnAST);
2169 statement_AST=(AST)currentAST.root;
2170 } else if(LA(1)==IDENT&&LA(2)==COLON) {
2171 AST tmp92_AST=null;
2172 tmp92_AST=astFactory.create(LT(1));
2173 astFactory.addASTChild(currentAST, tmp92_AST);
2174 match(IDENT);
2175 c=LT(1);
2176 c_AST=astFactory.create(c);
2177 astFactory.makeASTRoot(currentAST, c_AST);
2178 match(COLON);
2179 if(inputState.guessing==0) {
2180 c_AST.setType(LABELED_STAT);
2181 }
2182 statement();
2183 astFactory.addASTChild(currentAST, returnAST);
2184 statement_AST=(AST)currentAST.root;
2185 } else if(LA(1)==LITERAL_synchronized&&LA(2)==LPAREN) {
2186 sy=LT(1);
2187 sy_AST=astFactory.create(sy);
2188 astFactory.makeASTRoot(currentAST, sy_AST);
2189 match(LITERAL_synchronized);
2190 match(LPAREN);
2191 expression();
2192 astFactory.addASTChild(currentAST, returnAST);
2193 match(RPAREN);
2194 compoundStatement();
2195 astFactory.addASTChild(currentAST, returnAST);
2196 if(inputState.guessing==0) {
2197 sy_AST.setType(SYNCHRONIZED);
2198 }
2199 statement_AST=(AST)currentAST.root;
2200 } else {
2201 throw new NoViableAltException(LT(1), getFilename());
2202 }
2203 }
2204 returnAST=statement_AST;
2205 }
2206 /***
2207 */
2208 public final void argList() throws RecognitionException,
2209 TokenStreamException
2210 {
2211 returnAST=null;
2212 ASTPair currentAST=new ASTPair();
2213 AST argList_AST=null;
2214 {
2215 switch(LA(1)) {
2216 case LITERAL_void:
2217 case LITERAL_boolean:
2218 case LITERAL_byte:
2219 case LITERAL_char:
2220 case LITERAL_short:
2221 case LITERAL_int:
2222 case LITERAL_float:
2223 case LITERAL_long:
2224 case LITERAL_double:
2225 case IDENT:
2226 case LPAREN:
2227 case LITERAL_this:
2228 case LITERAL_super:
2229 case PLUS:
2230 case MINUS:
2231 case INC:
2232 case DEC:
2233 case BNOT:
2234 case LNOT:
2235 case LITERAL_true:
2236 case LITERAL_false:
2237 case LITERAL_null:
2238 case LITERAL_new:
2239 case NUM_INT:
2240 case CHAR_LITERAL:
2241 case STRING_LITERAL:
2242 case NUM_FLOAT:
2243 case NUM_LONG:
2244 case NUM_DOUBLE:
2245
2246 {
2247 expressionList();
2248 astFactory.addASTChild(currentAST, returnAST);
2249 break;
2250 }
2251 case RPAREN:
2252
2253 {
2254 if(inputState.guessing==0) {
2255 argList_AST=(AST)currentAST.root;
2256 argList_AST=astFactory.create(ELIST, "ELIST");
2257 currentAST.root=argList_AST;
2258 currentAST.child=((argList_AST!=null&&
2259 argList_AST.getFirstChild()!=null)?argList_AST.getFirstChild():argList_AST);
2260 currentAST.advanceChildToEnd();
2261 }
2262 break;
2263 }
2264 default:
2265
2266 {
2267 throw new NoViableAltException(LT(1), getFilename());
2268 }
2269 }
2270 }
2271 argList_AST=(AST)currentAST.root;
2272 returnAST=argList_AST;
2273 }
2274 /***
2275 * Declaration of a variable. This can be a class/instance variable,
2276 * or a local variable in a method It can also include possible
2277 * initialization.
2278 *
2279 * @param mods
2280 * @param t
2281 */
2282 public final void variableDeclarator(AST mods,
2283 AST t) throws RecognitionException,
2284 TokenStreamException
2285 {
2286 returnAST=null;
2287 ASTPair currentAST=new ASTPair();
2288 AST variableDeclarator_AST=null;
2289 Token id=null;
2290 AST id_AST=null;
2291 AST d_AST=null;
2292 AST v_AST=null;
2293 id=LT(1);
2294 id_AST=astFactory.create(id);
2295 match(IDENT);
2296 declaratorBrackets(t);
2297 d_AST=(AST)returnAST;
2298 varInitializer();
2299 v_AST=(AST)returnAST;
2300 if(inputState.guessing==0) {
2301 variableDeclarator_AST=(AST)currentAST.root;
2302 variableDeclarator_AST=(AST)astFactory.make((new ASTArray(5)).add(astFactory.create(VARIABLE_DEF,
2303 "VARIABLE_DEF")).add(mods).add((AST)astFactory.make((new ASTArray(2)).add(astFactory.create(TYPE,
2304 "TYPE")).add(d_AST))).add(id_AST).add(v_AST));
2305 currentAST.root=variableDeclarator_AST;
2306 currentAST.child=((variableDeclarator_AST!=null&&
2307 variableDeclarator_AST.getFirstChild()!=null)?variableDeclarator_AST.getFirstChild():variableDeclarator_AST);
2308 currentAST.advanceChildToEnd();
2309 }
2310 returnAST=variableDeclarator_AST;
2311 }
2312 /***
2313 */
2314 public final void varInitializer() throws RecognitionException,
2315 TokenStreamException
2316 {
2317 returnAST=null;
2318 ASTPair currentAST=new ASTPair();
2319 AST varInitializer_AST=null;
2320 {
2321 switch(LA(1)) {
2322 case ASSIGN:
2323
2324 {
2325 AST tmp95_AST=null;
2326 tmp95_AST=astFactory.create(LT(1));
2327 astFactory.makeASTRoot(currentAST, tmp95_AST);
2328 match(ASSIGN);
2329 initializer();
2330 astFactory.addASTChild(currentAST, returnAST);
2331 break;
2332 }
2333 case SEMI:
2334 case COMMA:
2335
2336 {
2337 break;
2338 }
2339 default:
2340
2341 {
2342 throw new NoViableAltException(LT(1), getFilename());
2343 }
2344 }
2345 }
2346 varInitializer_AST=(AST)currentAST.root;
2347 returnAST=varInitializer_AST;
2348 }
2349 /***
2350 */
2351 public final void initializer() throws RecognitionException,
2352 TokenStreamException
2353 {
2354 returnAST=null;
2355 ASTPair currentAST=new ASTPair();
2356 AST initializer_AST=null;
2357 switch(LA(1)) {
2358 case LITERAL_void:
2359 case LITERAL_boolean:
2360 case LITERAL_byte:
2361 case LITERAL_char:
2362 case LITERAL_short:
2363 case LITERAL_int:
2364 case LITERAL_float:
2365 case LITERAL_long:
2366 case LITERAL_double:
2367 case IDENT:
2368 case LPAREN:
2369 case LITERAL_this:
2370 case LITERAL_super:
2371 case PLUS:
2372 case MINUS:
2373 case INC:
2374 case DEC:
2375 case BNOT:
2376 case LNOT:
2377 case LITERAL_true:
2378 case LITERAL_false:
2379 case LITERAL_null:
2380 case LITERAL_new:
2381 case NUM_INT:
2382 case CHAR_LITERAL:
2383 case STRING_LITERAL:
2384 case NUM_FLOAT:
2385 case NUM_LONG:
2386 case NUM_DOUBLE:
2387
2388 {
2389 expression();
2390 astFactory.addASTChild(currentAST, returnAST);
2391 initializer_AST=(AST)currentAST.root;
2392 break;
2393 }
2394 case LCURLY:
2395
2396 {
2397 arrayInitializer();
2398 astFactory.addASTChild(currentAST, returnAST);
2399 initializer_AST=(AST)currentAST.root;
2400 break;
2401 }
2402 default:
2403
2404 {
2405 throw new NoViableAltException(LT(1), getFilename());
2406 }
2407 }
2408 returnAST=initializer_AST;
2409 }
2410 /***
2411 */
2412 public final void arrayInitializer() throws RecognitionException,
2413 TokenStreamException
2414 {
2415 returnAST=null;
2416 ASTPair currentAST=new ASTPair();
2417 AST arrayInitializer_AST=null;
2418 Token lc=null;
2419 AST lc_AST=null;
2420 lc=LT(1);
2421 lc_AST=astFactory.create(lc);
2422 astFactory.makeASTRoot(currentAST, lc_AST);
2423 match(LCURLY);
2424 if(inputState.guessing==0) {
2425 lc_AST.setType(ARRAY_INIT);
2426 }
2427 {
2428 switch(LA(1)) {
2429 case LITERAL_void:
2430 case LITERAL_boolean:
2431 case LITERAL_byte:
2432 case LITERAL_char:
2433 case LITERAL_short:
2434 case LITERAL_int:
2435 case LITERAL_float:
2436 case LITERAL_long:
2437 case LITERAL_double:
2438 case IDENT:
2439 case LCURLY:
2440 case LPAREN:
2441 case LITERAL_this:
2442 case LITERAL_super:
2443 case PLUS:
2444 case MINUS:
2445 case INC:
2446 case DEC:
2447 case BNOT:
2448 case LNOT:
2449 case LITERAL_true:
2450 case LITERAL_false:
2451 case LITERAL_null:
2452 case LITERAL_new:
2453 case NUM_INT:
2454 case CHAR_LITERAL:
2455 case STRING_LITERAL:
2456 case NUM_FLOAT:
2457 case NUM_LONG:
2458 case NUM_DOUBLE:
2459
2460 {
2461 initializer();
2462 astFactory.addASTChild(currentAST, returnAST);
2463 {
2464 _loop69:
2465
2466 do {
2467 if(LA(1)==COMMA&&_tokenSet_19.member(LA(2))) {
2468 match(COMMA);
2469 initializer();
2470 astFactory.addASTChild(currentAST,
2471 returnAST);
2472 } else {
2473 break _loop69;
2474 }
2475 } while(true);
2476
2477 }
2478 {
2479 switch(LA(1)) {
2480 case COMMA:
2481
2482 {
2483 match(COMMA);
2484 break;
2485 }
2486 case RCURLY:
2487
2488 {
2489 break;
2490 }
2491 default:
2492
2493 {
2494 throw new NoViableAltException(LT(1),
2495 getFilename());
2496 }
2497 }
2498 }
2499 break;
2500 }
2501 case RCURLY:
2502
2503 {
2504 break;
2505 }
2506 default:
2507
2508 {
2509 throw new NoViableAltException(LT(1), getFilename());
2510 }
2511 }
2512 }
2513 match(RCURLY);
2514 arrayInitializer_AST=(AST)currentAST.root;
2515 returnAST=arrayInitializer_AST;
2516 }
2517 /***
2518 */
2519 public final void expression() throws RecognitionException,
2520 TokenStreamException
2521 {
2522 returnAST=null;
2523 ASTPair currentAST=new ASTPair();
2524 AST expression_AST=null;
2525 assignmentExpression();
2526 astFactory.addASTChild(currentAST, returnAST);
2527 if(inputState.guessing==0) {
2528 expression_AST=(AST)currentAST.root;
2529 expression_AST=(AST)astFactory.make((new ASTArray(2)).add(astFactory.create(EXPR,
2530 "EXPR")).add(expression_AST));
2531 currentAST.root=expression_AST;
2532 currentAST.child=((expression_AST!=null&&
2533 expression_AST.getFirstChild()!=null)?expression_AST.getFirstChild():expression_AST);
2534 currentAST.advanceChildToEnd();
2535 }
2536 expression_AST=(AST)currentAST.root;
2537 returnAST=expression_AST;
2538 }
2539 /***
2540 */
2541 public final void parameterDeclaration() throws RecognitionException,
2542 TokenStreamException
2543 {
2544 returnAST=null;
2545 ASTPair currentAST=new ASTPair();
2546 AST parameterDeclaration_AST=null;
2547 AST pm_AST=null;
2548 AST t_AST=null;
2549 Token id=null;
2550 AST id_AST=null;
2551 AST pd_AST=null;
2552 parameterModifier();
2553 pm_AST=(AST)returnAST;
2554 typeSpec(false);
2555 t_AST=(AST)returnAST;
2556 id=LT(1);
2557 id_AST=astFactory.create(id);
2558 match(IDENT);
2559 declaratorBrackets(t_AST);
2560 pd_AST=(AST)returnAST;
2561 if(inputState.guessing==0) {
2562 parameterDeclaration_AST=(AST)currentAST.root;
2563 parameterDeclaration_AST=(AST)astFactory.make((new ASTArray(4)).add(astFactory.create(PARAMETER_DEF,
2564 "PARAMETER_DEF")).add(pm_AST).add((AST)astFactory.make((new ASTArray(2)).add(astFactory.create(TYPE,
2565 "TYPE")).add(pd_AST))).add(id_AST));
2566 currentAST.root=parameterDeclaration_AST;
2567 currentAST.child=((parameterDeclaration_AST!=null&&
2568 parameterDeclaration_AST.getFirstChild()!=null)?parameterDeclaration_AST.getFirstChild():parameterDeclaration_AST);
2569 currentAST.advanceChildToEnd();
2570 }
2571 returnAST=parameterDeclaration_AST;
2572 }
2573 /***
2574 */
2575 public final void parameterModifier() throws RecognitionException,
2576 TokenStreamException
2577 {
2578 returnAST=null;
2579 ASTPair currentAST=new ASTPair();
2580 AST parameterModifier_AST=null;
2581 Token f=null;
2582 AST f_AST=null;
2583 {
2584 switch(LA(1)) {
2585 case FINAL:
2586
2587 {
2588 f=LT(1);
2589 f_AST=astFactory.create(f);
2590 astFactory.addASTChild(currentAST, f_AST);
2591 match(FINAL);
2592 break;
2593 }
2594 case LITERAL_void:
2595 case LITERAL_boolean:
2596 case LITERAL_byte:
2597 case LITERAL_char:
2598 case LITERAL_short:
2599 case LITERAL_int:
2600 case LITERAL_float:
2601 case LITERAL_long:
2602 case LITERAL_double:
2603 case IDENT:
2604
2605 {
2606 break;
2607 }
2608 default:
2609
2610 {
2611 throw new NoViableAltException(LT(1), getFilename());
2612 }
2613 }
2614 }
2615 if(inputState.guessing==0) {
2616 parameterModifier_AST=(AST)currentAST.root;
2617 parameterModifier_AST=(AST)astFactory.make((new ASTArray(2)).add(astFactory.create(MODIFIERS,
2618 "MODIFIERS")).add(f_AST));
2619 currentAST.root=parameterModifier_AST;
2620 currentAST.child=((parameterModifier_AST!=null&&
2621 parameterModifier_AST.getFirstChild()!=null)?parameterModifier_AST.getFirstChild():parameterModifier_AST);
2622 currentAST.advanceChildToEnd();
2623 }
2624 parameterModifier_AST=(AST)currentAST.root;
2625 returnAST=parameterModifier_AST;
2626 }
2627 /***
2628 */
2629 public final void forInit() throws RecognitionException,
2630 TokenStreamException
2631 {
2632 returnAST=null;
2633 ASTPair currentAST=new ASTPair();
2634 AST forInit_AST=null;
2635 {
2636 boolean synPredMatched107=false;
2637 if(_tokenSet_13.member(LA(1))&&_tokenSet_14.member(LA(2))) {
2638 int _m107=mark();
2639 synPredMatched107=true;
2640 inputState.guessing++;
2641 try{
2642 {
2643 declaration();
2644 }
2645 }catch (RecognitionException pe) {
2646 synPredMatched107=false;
2647 }
2648 rewind(_m107);
2649 inputState.guessing--;
2650 }
2651 if(synPredMatched107) {
2652 declaration();
2653 astFactory.addASTChild(currentAST, returnAST);
2654 } else if(_tokenSet_15.member(LA(1))&&_tokenSet_20.member(LA(2))) {
2655 expressionList();
2656 astFactory.addASTChild(currentAST, returnAST);
2657 } else if(LA(1)==SEMI) {
2658 } else {
2659 throw new NoViableAltException(LT(1), getFilename());
2660 }
2661 }
2662 if(inputState.guessing==0) {
2663 forInit_AST=(AST)currentAST.root;
2664 forInit_AST=(AST)astFactory.make((new ASTArray(2)).add(astFactory.create(FOR_INIT,
2665 "FOR_INIT")).add(forInit_AST));
2666 currentAST.root=forInit_AST;
2667 currentAST.child=((forInit_AST!=null&&
2668 forInit_AST.getFirstChild()!=null)?forInit_AST.getFirstChild():forInit_AST);
2669 currentAST.advanceChildToEnd();
2670 }
2671 forInit_AST=(AST)currentAST.root;
2672 returnAST=forInit_AST;
2673 }
2674 /***
2675 */
2676 public final void forCond() throws RecognitionException,
2677 TokenStreamException
2678 {
2679 returnAST=null;
2680 ASTPair currentAST=new ASTPair();
2681 AST forCond_AST=null;
2682 {
2683 switch(LA(1)) {
2684 case LITERAL_void:
2685 case LITERAL_boolean:
2686 case LITERAL_byte:
2687 case LITERAL_char:
2688 case LITERAL_short:
2689 case LITERAL_int:
2690 case LITERAL_float:
2691 case LITERAL_long:
2692 case LITERAL_double:
2693 case IDENT:
2694 case LPAREN:
2695 case LITERAL_this:
2696 case LITERAL_super:
2697 case PLUS:
2698 case MINUS:
2699 case INC:
2700 case DEC:
2701 case BNOT:
2702 case LNOT:
2703 case LITERAL_true:
2704 case LITERAL_false:
2705 case LITERAL_null:
2706 case LITERAL_new:
2707 case NUM_INT:
2708 case CHAR_LITERAL:
2709 case STRING_LITERAL:
2710 case NUM_FLOAT:
2711 case NUM_LONG:
2712 case NUM_DOUBLE:
2713
2714 {
2715 expression();
2716 astFactory.addASTChild(currentAST, returnAST);
2717 break;
2718 }
2719 case SEMI:
2720
2721 {
2722 break;
2723 }
2724 default:
2725
2726 {
2727 throw new NoViableAltException(LT(1), getFilename());
2728 }
2729 }
2730 }
2731 if(inputState.guessing==0) {
2732 forCond_AST=(AST)currentAST.root;
2733 forCond_AST=(AST)astFactory.make((new ASTArray(2)).add(astFactory.create(FOR_CONDITION,
2734 "FOR_CONDITION")).add(forCond_AST));
2735 currentAST.root=forCond_AST;
2736 currentAST.child=((forCond_AST!=null&&
2737 forCond_AST.getFirstChild()!=null)?forCond_AST.getFirstChild():forCond_AST);
2738 currentAST.advanceChildToEnd();
2739 }
2740 forCond_AST=(AST)currentAST.root;
2741 returnAST=forCond_AST;
2742 }
2743 /***
2744 */
2745 public final void forIter() throws RecognitionException,
2746 TokenStreamException
2747 {
2748 returnAST=null;
2749 ASTPair currentAST=new ASTPair();
2750 AST forIter_AST=null;
2751 {
2752 switch(LA(1)) {
2753 case LITERAL_void:
2754 case LITERAL_boolean:
2755 case LITERAL_byte:
2756 case LITERAL_char:
2757 case LITERAL_short:
2758 case LITERAL_int:
2759 case LITERAL_float:
2760 case LITERAL_long:
2761 case LITERAL_double:
2762 case IDENT:
2763 case LPAREN:
2764 case LITERAL_this:
2765 case LITERAL_super:
2766 case PLUS:
2767 case MINUS:
2768 case INC:
2769 case DEC:
2770 case BNOT:
2771 case LNOT:
2772 case LITERAL_true:
2773 case LITERAL_false:
2774 case LITERAL_null:
2775 case LITERAL_new:
2776 case NUM_INT:
2777 case CHAR_LITERAL:
2778 case STRING_LITERAL:
2779 case NUM_FLOAT:
2780 case NUM_LONG:
2781 case NUM_DOUBLE:
2782
2783 {
2784 expressionList();
2785 astFactory.addASTChild(currentAST, returnAST);
2786 break;
2787 }
2788 case RPAREN:
2789
2790 {
2791 break;
2792 }
2793 default:
2794
2795 {
2796 throw new NoViableAltException(LT(1), getFilename());
2797 }
2798 }
2799 }
2800 if(inputState.guessing==0) {
2801 forIter_AST=(AST)currentAST.root;
2802 forIter_AST=(AST)astFactory.make((new ASTArray(2)).add(astFactory.create(FOR_ITERATOR,
2803 "FOR_ITERATOR")).add(forIter_AST));
2804 currentAST.root=forIter_AST;
2805 currentAST.child=((forIter_AST!=null&&
2806 forIter_AST.getFirstChild()!=null)?forIter_AST.getFirstChild():forIter_AST);
2807 currentAST.advanceChildToEnd();
2808 }
2809 forIter_AST=(AST)currentAST.root;
2810 returnAST=forIter_AST;
2811 }
2812 /***
2813 */
2814 public final void casesGroup() throws RecognitionException,
2815 TokenStreamException
2816 {
2817 returnAST=null;
2818 ASTPair currentAST=new ASTPair();
2819 AST casesGroup_AST=null;
2820 {
2821 int _cnt98=0;
2822 _loop98:
2823
2824 do {
2825 if((LA(1)==LITERAL_case||
2826 LA(1)==LITERAL_default)&&_tokenSet_21.member(LA(2))) {
2827 aCase();
2828 astFactory.addASTChild(currentAST, returnAST);
2829 } else {
2830 if(_cnt98>=1) {
2831 break _loop98;
2832 } else {
2833 throw new NoViableAltException(LT(1),
2834 getFilename());
2835 }
2836 }
2837 _cnt98++;
2838 } while(true);
2839
2840 }
2841 caseSList();
2842 astFactory.addASTChild(currentAST, returnAST);
2843 if(inputState.guessing==0) {
2844 casesGroup_AST=(AST)currentAST.root;
2845 casesGroup_AST=(AST)astFactory.make((new ASTArray(2)).add(astFactory.create(CASE_GROUP,
2846 "CASE_GROUP")).add(casesGroup_AST));
2847 currentAST.root=casesGroup_AST;
2848 currentAST.child=((casesGroup_AST!=null&&
2849 casesGroup_AST.getFirstChild()!=null)?casesGroup_AST.getFirstChild():casesGroup_AST);
2850 currentAST.advanceChildToEnd();
2851 }
2852 casesGroup_AST=(AST)currentAST.root;
2853 returnAST=casesGroup_AST;
2854 }
2855 /***
2856 */
2857 public final void tryBlock() throws RecognitionException,
2858 TokenStreamException
2859 {
2860 returnAST=null;
2861 ASTPair currentAST=new ASTPair();
2862 AST tryBlock_AST=null;
2863 Token t=null;
2864 AST t_AST=null;
2865 t=LT(1);
2866 t_AST=astFactory.create(t);
2867 astFactory.makeASTRoot(currentAST, t_AST);
2868 match(LITERAL_try);
2869 compoundStatement();
2870 astFactory.addASTChild(currentAST, returnAST);
2871 {
2872 _loop114:
2873
2874 do {
2875 if(LA(1)==LITERAL_catch) {
2876 handler();
2877 astFactory.addASTChild(currentAST, returnAST);
2878 } else {
2879 break _loop114;
2880 }
2881 } while(true);
2882
2883 }
2884 {
2885 switch(LA(1)) {
2886 case LITERAL_finally:
2887
2888 {
2889 finallyClause();
2890 astFactory.addASTChild(currentAST, returnAST);
2891 break;
2892 }
2893 case FINAL:
2894 case ABSTRACT:
2895 case STRICTFP:
2896 case SEMI:
2897 case LITERAL_void:
2898 case LITERAL_boolean:
2899 case LITERAL_byte:
2900 case LITERAL_char:
2901 case LITERAL_short:
2902 case LITERAL_int:
2903 case LITERAL_float:
2904 case LITERAL_long:
2905 case LITERAL_double:
2906 case IDENT:
2907 case LITERAL_private:
2908 case LITERAL_public:
2909 case LITERAL_protected:
2910 case LITERAL_static:
2911 case LITERAL_transient:
2912 case LITERAL_native:
2913 case LITERAL_threadsafe:
2914 case LITERAL_synchronized:
2915 case LITERAL_volatile:
2916 case LITERAL_class:
2917 case LCURLY:
2918 case RCURLY:
2919 case LPAREN:
2920 case LITERAL_this:
2921 case LITERAL_super:
2922 case LITERAL_if:
2923 case LITERAL_else:
2924 case LITERAL_for:
2925 case LITERAL_while:
2926 case LITERAL_do:
2927 case LITERAL_break:
2928 case LITERAL_continue:
2929 case LITERAL_return:
2930 case LITERAL_switch:
2931 case LITERAL_throw:
2932 case LITERAL_case:
2933 case LITERAL_default:
2934 case LITERAL_try:
2935 case PLUS:
2936 case MINUS:
2937 case INC:
2938 case DEC:
2939 case BNOT:
2940 case LNOT:
2941 case LITERAL_true:
2942 case LITERAL_false:
2943 case LITERAL_null:
2944 case LITERAL_new:
2945 case NUM_INT:
2946 case CHAR_LITERAL:
2947 case STRING_LITERAL:
2948 case NUM_FLOAT:
2949 case NUM_LONG:
2950 case NUM_DOUBLE:
2951
2952 {
2953 break;
2954 }
2955 default:
2956
2957 {
2958 throw new NoViableAltException(LT(1), getFilename());
2959 }
2960 }
2961 }
2962 if(inputState.guessing==0) {
2963 t_AST.setType(TRY_BLOCK);
2964 }
2965 tryBlock_AST=(AST)currentAST.root;
2966 returnAST=tryBlock_AST;
2967 }
2968 /***
2969 */
2970 public final void aCase() throws RecognitionException,
2971 TokenStreamException
2972 {
2973 returnAST=null;
2974 ASTPair currentAST=new ASTPair();
2975 AST aCase_AST=null;
2976 Token c=null;
2977 AST c_AST=null;
2978 Token d=null;
2979 AST d_AST=null;
2980 {
2981 switch(LA(1)) {
2982 case LITERAL_case:
2983
2984 {
2985 c=LT(1);
2986 c_AST=astFactory.create(c);
2987 astFactory.makeASTRoot(currentAST, c_AST);
2988 match(LITERAL_case);
2989 expression();
2990 astFactory.addASTChild(currentAST, returnAST);
2991 if(inputState.guessing==0) {
2992 c_AST.setType(CASE);
2993 }
2994 break;
2995 }
2996 case LITERAL_default:
2997
2998 {
2999 d=LT(1);
3000 d_AST=astFactory.create(d);
3001 astFactory.addASTChild(currentAST, d_AST);
3002 match(LITERAL_default);
3003 if(inputState.guessing==0) {
3004 d_AST.setType(CASE);
3005 }
3006 break;
3007 }
3008 default:
3009
3010 {
3011 throw new NoViableAltException(LT(1), getFilename());
3012 }
3013 }
3014 }
3015 match(COLON);
3016 aCase_AST=(AST)currentAST.root;
3017 returnAST=aCase_AST;
3018 }
3019 /***
3020 */
3021 public final void caseSList() throws RecognitionException,
3022 TokenStreamException
3023 {
3024 returnAST=null;
3025 ASTPair currentAST=new ASTPair();
3026 AST caseSList_AST=null;
3027 {
3028 _loop103:
3029
3030 do {
3031 if(_tokenSet_10.member(LA(1))) {
3032 statement();
3033 astFactory.addASTChild(currentAST, returnAST);
3034 } else {
3035 break _loop103;
3036 }
3037 } while(true);
3038
3039 }
3040 if(inputState.guessing==0) {
3041 caseSList_AST=(AST)currentAST.root;
3042 caseSList_AST=(AST)astFactory.make((new ASTArray(2)).add(astFactory.create(SLIST,
3043 "SLIST")).add(caseSList_AST));
3044 currentAST.root=caseSList_AST;
3045 currentAST.child=((caseSList_AST!=null&&
3046 caseSList_AST.getFirstChild()!=null)?caseSList_AST.getFirstChild():caseSList_AST);
3047 currentAST.advanceChildToEnd();
3048 }
3049 caseSList_AST=(AST)currentAST.root;
3050 returnAST=caseSList_AST;
3051 }
3052 /***
3053 */
3054 public final void expressionList() throws RecognitionException,
3055 TokenStreamException
3056 {
3057 returnAST=null;
3058 ASTPair currentAST=new ASTPair();
3059 AST expressionList_AST=null;
3060 expression();
3061 astFactory.addASTChild(currentAST, returnAST);
3062 {
3063 _loop121:
3064
3065 do {
3066 if(LA(1)==COMMA) {
3067 match(COMMA);
3068 expression();
3069 astFactory.addASTChild(currentAST, returnAST);
3070 } else {
3071 break _loop121;
3072 }
3073 } while(true);
3074
3075 }
3076 if(inputState.guessing==0) {
3077 expressionList_AST=(AST)currentAST.root;
3078 expressionList_AST=(AST)astFactory.make((new ASTArray(2)).add(astFactory.create(ELIST,
3079 "ELIST")).add(expressionList_AST));
3080 currentAST.root=expressionList_AST;
3081 currentAST.child=((expressionList_AST!=null&&
3082 expressionList_AST.getFirstChild()!=null)?expressionList_AST.getFirstChild():expressionList_AST);
3083 currentAST.advanceChildToEnd();
3084 }
3085 expressionList_AST=(AST)currentAST.root;
3086 returnAST=expressionList_AST;
3087 }
3088 /***
3089 */
3090 public final void handler() throws RecognitionException,
3091 TokenStreamException
3092 {
3093 returnAST=null;
3094 ASTPair currentAST=new ASTPair();
3095 AST handler_AST=null;
3096 Token h=null;
3097 AST h_AST=null;
3098 h=LT(1);
3099 h_AST=astFactory.create(h);
3100 astFactory.makeASTRoot(currentAST, h_AST);
3101 match(LITERAL_catch);
3102 match(LPAREN);
3103 parameterDeclaration();
3104 astFactory.addASTChild(currentAST, returnAST);
3105 match(RPAREN);
3106 compoundStatement();
3107 astFactory.addASTChild(currentAST, returnAST);
3108 if(inputState.guessing==0) {
3109 h_AST.setType(HANDLER);
3110 }
3111 handler_AST=(AST)currentAST.root;
3112 returnAST=handler_AST;
3113 }
3114 /***
3115 */
3116 public final void finallyClause() throws RecognitionException,
3117 TokenStreamException
3118 {
3119 returnAST=null;
3120 ASTPair currentAST=new ASTPair();
3121 AST finallyClause_AST=null;
3122 Token f=null;
3123 AST f_AST=null;
3124 f=LT(1);
3125 f_AST=astFactory.create(f);
3126 astFactory.makeASTRoot(currentAST, f_AST);
3127 match(LITERAL_finally);
3128 compoundStatement();
3129 astFactory.addASTChild(currentAST, returnAST);
3130 if(inputState.guessing==0) {
3131 f_AST.setType(FINALLY_CLAUSE);
3132 }
3133 finallyClause_AST=(AST)currentAST.root;
3134 returnAST=finallyClause_AST;
3135 }
3136 /***
3137 */
3138 public final void assignmentExpression() throws RecognitionException,
3139 TokenStreamException
3140 {
3141 returnAST=null;
3142 ASTPair currentAST=new ASTPair();
3143 AST assignmentExpression_AST=null;
3144 conditionalExpression();
3145 astFactory.addASTChild(currentAST, returnAST);
3146 {
3147 switch(LA(1)) {
3148 case ASSIGN:
3149 case PLUS_ASSIGN:
3150 case MINUS_ASSIGN:
3151 case STAR_ASSIGN:
3152 case DIV_ASSIGN:
3153 case MOD_ASSIGN:
3154 case SR_ASSIGN:
3155 case BSR_ASSIGN:
3156 case SL_ASSIGN:
3157 case BAND_ASSIGN:
3158 case BXOR_ASSIGN:
3159 case BOR_ASSIGN:
3160
3161 {
3162 {
3163 switch(LA(1)) {
3164 case ASSIGN:
3165
3166 {
3167 AST tmp103_AST=null;
3168 tmp103_AST=astFactory.create(LT(1));
3169 astFactory.makeASTRoot(currentAST,
3170 tmp103_AST);
3171 match(ASSIGN);
3172 break;
3173 }
3174 case PLUS_ASSIGN:
3175
3176 {
3177 AST tmp104_AST=null;
3178 tmp104_AST=astFactory.create(LT(1));
3179 astFactory.makeASTRoot(currentAST,
3180 tmp104_AST);
3181 match(PLUS_ASSIGN);
3182 break;
3183 }
3184 case MINUS_ASSIGN:
3185
3186 {
3187 AST tmp105_AST=null;
3188 tmp105_AST=astFactory.create(LT(1));
3189 astFactory.makeASTRoot(currentAST,
3190 tmp105_AST);
3191 match(MINUS_ASSIGN);
3192 break;
3193 }
3194 case STAR_ASSIGN:
3195
3196 {
3197 AST tmp106_AST=null;
3198 tmp106_AST=astFactory.create(LT(1));
3199 astFactory.makeASTRoot(currentAST,
3200 tmp106_AST);
3201 match(STAR_ASSIGN);
3202 break;
3203 }
3204 case DIV_ASSIGN:
3205
3206 {
3207 AST tmp107_AST=null;
3208 tmp107_AST=astFactory.create(LT(1));
3209 astFactory.makeASTRoot(currentAST,
3210 tmp107_AST);
3211 match(DIV_ASSIGN);
3212 break;
3213 }
3214 case MOD_ASSIGN:
3215
3216 {
3217 AST tmp108_AST=null;
3218 tmp108_AST=astFactory.create(LT(1));
3219 astFactory.makeASTRoot(currentAST,
3220 tmp108_AST);
3221 match(MOD_ASSIGN);
3222 break;
3223 }
3224 case SR_ASSIGN:
3225
3226 {
3227 AST tmp109_AST=null;
3228 tmp109_AST=astFactory.create(LT(1));
3229 astFactory.makeASTRoot(currentAST,
3230 tmp109_AST);
3231 match(SR_ASSIGN);
3232 break;
3233 }
3234 case BSR_ASSIGN:
3235
3236 {
3237 AST tmp110_AST=null;
3238 tmp110_AST=astFactory.create(LT(1));
3239 astFactory.makeASTRoot(currentAST,
3240 tmp110_AST);
3241 match(BSR_ASSIGN);
3242 break;
3243 }
3244 case SL_ASSIGN:
3245
3246 {
3247 AST tmp111_AST=null;
3248 tmp111_AST=astFactory.create(LT(1));
3249 astFactory.makeASTRoot(currentAST,
3250 tmp111_AST);
3251 match(SL_ASSIGN);
3252 break;
3253 }
3254 case BAND_ASSIGN:
3255
3256 {
3257 AST tmp112_AST=null;
3258 tmp112_AST=astFactory.create(LT(1));
3259 astFactory.makeASTRoot(currentAST,
3260 tmp112_AST);
3261 match(BAND_ASSIGN);
3262 break;
3263 }
3264 case BXOR_ASSIGN:
3265
3266 {
3267 AST tmp113_AST=null;
3268 tmp113_AST=astFactory.create(LT(1));
3269 astFactory.makeASTRoot(currentAST,
3270 tmp113_AST);
3271 match(BXOR_ASSIGN);
3272 break;
3273 }
3274 case BOR_ASSIGN:
3275
3276 {
3277 AST tmp114_AST=null;
3278 tmp114_AST=astFactory.create(LT(1));
3279 astFactory.makeASTRoot(currentAST,
3280 tmp114_AST);
3281 match(BOR_ASSIGN);
3282 break;
3283 }
3284 default:
3285
3286 {
3287 throw new NoViableAltException(LT(1),
3288 getFilename());
3289 }
3290 }
3291 }
3292 assignmentExpression();
3293 astFactory.addASTChild(currentAST, returnAST);
3294 break;
3295 }
3296 case SEMI:
3297 case RBRACK:
3298 case RCURLY:
3299 case COMMA:
3300 case RPAREN:
3301 case COLON:
3302
3303 {
3304 break;
3305 }
3306 default:
3307
3308 {
3309 throw new NoViableAltException(LT(1), getFilename());
3310 }
3311 }
3312 }
3313 assignmentExpression_AST=(AST)currentAST.root;
3314 returnAST=assignmentExpression_AST;
3315 }
3316 /***
3317 */
3318 public final void conditionalExpression() throws RecognitionException,
3319 TokenStreamException
3320 {
3321 returnAST=null;
3322 ASTPair currentAST=new ASTPair();
3323 AST conditionalExpression_AST=null;
3324 logicalOrExpression();
3325 astFactory.addASTChild(currentAST, returnAST);
3326 {
3327 switch(LA(1)) {
3328 case QUESTION:
3329
3330 {
3331 AST tmp115_AST=null;
3332 tmp115_AST=astFactory.create(LT(1));
3333 astFactory.makeASTRoot(currentAST, tmp115_AST);
3334 match(QUESTION);
3335 assignmentExpression();
3336 astFactory.addASTChild(currentAST, returnAST);
3337 match(COLON);
3338 conditionalExpression();
3339 astFactory.addASTChild(currentAST, returnAST);
3340 break;
3341 }
3342 case SEMI:
3343 case RBRACK:
3344 case RCURLY:
3345 case COMMA:
3346 case RPAREN:
3347 case ASSIGN:
3348 case COLON:
3349 case PLUS_ASSIGN:
3350 case MINUS_ASSIGN:
3351 case STAR_ASSIGN:
3352 case DIV_ASSIGN:
3353 case MOD_ASSIGN:
3354 case SR_ASSIGN:
3355 case BSR_ASSIGN:
3356 case SL_ASSIGN:
3357 case BAND_ASSIGN:
3358 case BXOR_ASSIGN:
3359 case BOR_ASSIGN:
3360
3361 {
3362 break;
3363 }
3364 default:
3365
3366 {
3367 throw new NoViableAltException(LT(1), getFilename());
3368 }
3369 }
3370 }
3371 conditionalExpression_AST=(AST)currentAST.root;
3372 returnAST=conditionalExpression_AST;
3373 }
3374 /***
3375 */
3376 public final void logicalOrExpression() throws RecognitionException,
3377 TokenStreamException
3378 {
3379 returnAST=null;
3380 ASTPair currentAST=new ASTPair();
3381 AST logicalOrExpression_AST=null;
3382 logicalAndExpression();
3383 astFactory.addASTChild(currentAST, returnAST);
3384 {
3385 _loop129:
3386
3387 do {
3388 if(LA(1)==LOR) {
3389 AST tmp117_AST=null;
3390 tmp117_AST=astFactory.create(LT(1));
3391 astFactory.makeASTRoot(currentAST, tmp117_AST);
3392 match(LOR);
3393 logicalAndExpression();
3394 astFactory.addASTChild(currentAST, returnAST);
3395 } else {
3396 break _loop129;
3397 }
3398 } while(true);
3399
3400 }
3401 logicalOrExpression_AST=(AST)currentAST.root;
3402 returnAST=logicalOrExpression_AST;
3403 }
3404 /***
3405 */
3406 public final void logicalAndExpression() throws RecognitionException,
3407 TokenStreamException
3408 {
3409 returnAST=null;
3410 ASTPair currentAST=new ASTPair();
3411 AST logicalAndExpression_AST=null;
3412 inclusiveOrExpression();
3413 astFactory.addASTChild(currentAST, returnAST);
3414 {
3415 _loop132:
3416
3417 do {
3418 if(LA(1)==LAND) {
3419 AST tmp118_AST=null;
3420 tmp118_AST=astFactory.create(LT(1));
3421 astFactory.makeASTRoot(currentAST, tmp118_AST);
3422 match(LAND);
3423 inclusiveOrExpression();
3424 astFactory.addASTChild(currentAST, returnAST);
3425 } else {
3426 break _loop132;
3427 }
3428 } while(true);
3429
3430 }
3431 logicalAndExpression_AST=(AST)currentAST.root;
3432 returnAST=logicalAndExpression_AST;
3433 }
3434 /***
3435 */
3436 public final void inclusiveOrExpression() throws RecognitionException,
3437 TokenStreamException
3438 {
3439 returnAST=null;
3440 ASTPair currentAST=new ASTPair();
3441 AST inclusiveOrExpression_AST=null;
3442 exclusiveOrExpression();
3443 astFactory.addASTChild(currentAST, returnAST);
3444 {
3445 _loop135:
3446
3447 do {
3448 if(LA(1)==BOR) {
3449 AST tmp119_AST=null;
3450 tmp119_AST=astFactory.create(LT(1));
3451 astFactory.makeASTRoot(currentAST, tmp119_AST);
3452 match(BOR);
3453 exclusiveOrExpression();
3454 astFactory.addASTChild(currentAST, returnAST);
3455 } else {
3456 break _loop135;
3457 }
3458 } while(true);
3459
3460 }
3461 inclusiveOrExpression_AST=(AST)currentAST.root;
3462 returnAST=inclusiveOrExpression_AST;
3463 }
3464 /***
3465 */
3466 public final void exclusiveOrExpression() throws RecognitionException,
3467 TokenStreamException
3468 {
3469 returnAST=null;
3470 ASTPair currentAST=new ASTPair();
3471 AST exclusiveOrExpression_AST=null;
3472 andExpression();
3473 astFactory.addASTChild(currentAST, returnAST);
3474 {
3475 _loop138:
3476
3477 do {
3478 if(LA(1)==BXOR) {
3479 AST tmp120_AST=null;
3480 tmp120_AST=astFactory.create(LT(1));
3481 astFactory.makeASTRoot(currentAST, tmp120_AST);
3482 match(BXOR);
3483 andExpression();
3484 astFactory.addASTChild(currentAST, returnAST);
3485 } else {
3486 break _loop138;
3487 }
3488 } while(true);
3489
3490 }
3491 exclusiveOrExpression_AST=(AST)currentAST.root;
3492 returnAST=exclusiveOrExpression_AST;
3493 }
3494 /***
3495 */
3496 public final void andExpression() throws RecognitionException,
3497 TokenStreamException
3498 {
3499 returnAST=null;
3500 ASTPair currentAST=new ASTPair();
3501 AST andExpression_AST=null;
3502 equalityExpression();
3503 astFactory.addASTChild(currentAST, returnAST);
3504 {
3505 _loop141:
3506
3507 do {
3508 if(LA(1)==BAND) {
3509 AST tmp121_AST=null;
3510 tmp121_AST=astFactory.create(LT(1));
3511 astFactory.makeASTRoot(currentAST, tmp121_AST);
3512 match(BAND);
3513 equalityExpression();
3514 astFactory.addASTChild(currentAST, returnAST);
3515 } else {
3516 break _loop141;
3517 }
3518 } while(true);
3519
3520 }
3521 andExpression_AST=(AST)currentAST.root;
3522 returnAST=andExpression_AST;
3523 }
3524 /***
3525 */
3526 public final void equalityExpression() throws RecognitionException,
3527 TokenStreamException
3528 {
3529 returnAST=null;
3530 ASTPair currentAST=new ASTPair();
3531 AST equalityExpression_AST=null;
3532 relationalExpression();
3533 astFactory.addASTChild(currentAST, returnAST);
3534 {
3535 _loop145:
3536
3537 do {
3538 if(LA(1)==NOT_EQUAL||LA(1)==EQUAL) {
3539 {
3540 switch(LA(1)) {
3541 case NOT_EQUAL:
3542
3543 {
3544 AST tmp122_AST=null;
3545 tmp122_AST=astFactory.create(LT(1));
3546 astFactory.makeASTRoot(currentAST,
3547 tmp122_AST);
3548 match(NOT_EQUAL);
3549 break;
3550 }
3551 case EQUAL:
3552
3553 {
3554 AST tmp123_AST=null;
3555 tmp123_AST=astFactory.create(LT(1));
3556 astFactory.makeASTRoot(currentAST,
3557 tmp123_AST);
3558 match(EQUAL);
3559 break;
3560 }
3561 default:
3562
3563 {
3564 throw new NoViableAltException(LT(1),
3565 getFilename());
3566 }
3567 }
3568 }
3569 relationalExpression();
3570 astFactory.addASTChild(currentAST, returnAST);
3571 } else {
3572 break _loop145;
3573 }
3574 } while(true);
3575
3576 }
3577 equalityExpression_AST=(AST)currentAST.root;
3578 returnAST=equalityExpression_AST;
3579 }
3580 /***
3581 */
3582 public final void relationalExpression() throws RecognitionException,
3583 TokenStreamException
3584 {
3585 returnAST=null;
3586 ASTPair currentAST=new ASTPair();
3587 AST relationalExpression_AST=null;
3588 Token i=null;
3589 AST i_AST=null;
3590 shiftExpression();
3591 astFactory.addASTChild(currentAST, returnAST);
3592 {
3593 switch(LA(1)) {
3594 case SEMI:
3595 case RBRACK:
3596 case RCURLY:
3597 case COMMA:
3598 case RPAREN:
3599 case ASSIGN:
3600 case COLON:
3601 case PLUS_ASSIGN:
3602 case MINUS_ASSIGN:
3603 case STAR_ASSIGN:
3604 case DIV_ASSIGN:
3605 case MOD_ASSIGN:
3606 case SR_ASSIGN:
3607 case BSR_ASSIGN:
3608 case SL_ASSIGN:
3609 case BAND_ASSIGN:
3610 case BXOR_ASSIGN:
3611 case BOR_ASSIGN:
3612 case QUESTION:
3613 case LOR:
3614 case LAND:
3615 case BOR:
3616 case BXOR:
3617 case BAND:
3618 case NOT_EQUAL:
3619 case EQUAL:
3620 case LT:
3621 case GT:
3622 case LE:
3623 case GE:
3624
3625 {
3626 {
3627 _loop150:
3628
3629 do {
3630 if(LA(1)>=LT&&LA(1)<=GE) {
3631 {
3632 switch(LA(1)) {
3633 case LT:
3634
3635 {
3636 AST tmp124_AST=null;
3637 tmp124_AST=astFactory.create(LT(1));
3638 astFactory.makeASTRoot(currentAST,
3639 tmp124_AST);
3640 match(LT);
3641 break;
3642 }
3643 case GT:
3644
3645 {
3646 AST tmp125_AST=null;
3647 tmp125_AST=astFactory.create(LT(1));
3648 astFactory.makeASTRoot(currentAST,
3649 tmp125_AST);
3650 match(GT);
3651 break;
3652 }
3653 case LE:
3654
3655 {
3656 AST tmp126_AST=null;
3657 tmp126_AST=astFactory.create(LT(1));
3658 astFactory.makeASTRoot(currentAST,
3659 tmp126_AST);
3660 match(LE);
3661 break;
3662 }
3663 case GE:
3664
3665 {
3666 AST tmp127_AST=null;
3667 tmp127_AST=astFactory.create(LT(1));
3668 astFactory.makeASTRoot(currentAST,
3669 tmp127_AST);
3670 match(GE);
3671 break;
3672 }
3673 default:
3674
3675 {
3676 throw new NoViableAltException(LT(1),
3677 getFilename());
3678 }
3679 }
3680 }
3681 shiftExpression();
3682 astFactory.addASTChild(currentAST,
3683 returnAST);
3684 } else {
3685 break _loop150;
3686 }
3687 } while(true);
3688
3689 }
3690 break;
3691 }
3692 case LITERAL_instanceof:
3693
3694 {
3695 i=LT(1);
3696 i_AST=astFactory.create(i);
3697 astFactory.makeASTRoot(currentAST, i_AST);
3698 match(LITERAL_instanceof);
3699 typeSpec(true);
3700 astFactory.addASTChild(currentAST, returnAST);
3701 if(inputState.guessing==0) {
3702 i_AST.setType(INSTANCEOF);
3703 }
3704 break;
3705 }
3706 default:
3707
3708 {
3709 throw new NoViableAltException(LT(1), getFilename());
3710 }
3711 }
3712 }
3713 relationalExpression_AST=(AST)currentAST.root;
3714 returnAST=relationalExpression_AST;
3715 }
3716 /***
3717 */
3718 public final void shiftExpression() throws RecognitionException,
3719 TokenStreamException
3720 {
3721 returnAST=null;
3722 ASTPair currentAST=new ASTPair();
3723 AST shiftExpression_AST=null;
3724 additiveExpression();
3725 astFactory.addASTChild(currentAST, returnAST);
3726 {
3727 _loop154:
3728
3729 do {
3730 if(LA(1)>=SL&&LA(1)<=BSR) {
3731 {
3732 switch(LA(1)) {
3733 case SL:
3734
3735 {
3736 AST tmp128_AST=null;
3737 tmp128_AST=astFactory.create(LT(1));
3738 astFactory.makeASTRoot(currentAST,
3739 tmp128_AST);
3740 match(SL);
3741 break;
3742 }
3743 case SR:
3744
3745 {
3746 AST tmp129_AST=null;
3747 tmp129_AST=astFactory.create(LT(1));
3748 astFactory.makeASTRoot(currentAST,
3749 tmp129_AST);
3750 match(SR);
3751 break;
3752 }
3753 case BSR:
3754
3755 {
3756 AST tmp130_AST=null;
3757 tmp130_AST=astFactory.create(LT(1));
3758 astFactory.makeASTRoot(currentAST,
3759 tmp130_AST);
3760 match(BSR);
3761 break;
3762 }
3763 default:
3764
3765 {
3766 throw new NoViableAltException(LT(1),
3767 getFilename());
3768 }
3769 }
3770 }
3771 additiveExpression();
3772 astFactory.addASTChild(currentAST, returnAST);
3773 } else {
3774 break _loop154;
3775 }
3776 } while(true);
3777
3778 }
3779 shiftExpression_AST=(AST)currentAST.root;
3780 returnAST=shiftExpression_AST;
3781 }
3782 /***
3783 */
3784 public final void additiveExpression() throws RecognitionException,
3785 TokenStreamException
3786 {
3787 returnAST=null;
3788 ASTPair currentAST=new ASTPair();
3789 AST additiveExpression_AST=null;
3790 multiplicativeExpression();
3791 astFactory.addASTChild(currentAST, returnAST);
3792 {
3793 _loop158:
3794
3795 do {
3796 if(LA(1)==PLUS||LA(1)==MINUS) {
3797 {
3798 switch(LA(1)) {
3799 case PLUS:
3800
3801 {
3802 AST tmp131_AST=null;
3803 tmp131_AST=astFactory.create(LT(1));
3804 astFactory.makeASTRoot(currentAST,
3805 tmp131_AST);
3806 match(PLUS);
3807 break;
3808 }
3809 case MINUS:
3810
3811 {
3812 AST tmp132_AST=null;
3813 tmp132_AST=astFactory.create(LT(1));
3814 astFactory.makeASTRoot(currentAST,
3815 tmp132_AST);
3816 match(MINUS);
3817 break;
3818 }
3819 default:
3820
3821 {
3822 throw new NoViableAltException(LT(1),
3823 getFilename());
3824 }
3825 }
3826 }
3827 multiplicativeExpression();
3828 astFactory.addASTChild(currentAST, returnAST);
3829 } else {
3830 break _loop158;
3831 }
3832 } while(true);
3833
3834 }
3835 additiveExpression_AST=(AST)currentAST.root;
3836 returnAST=additiveExpression_AST;
3837 }
3838 /***
3839 */
3840 public final void multiplicativeExpression() throws RecognitionException,
3841 TokenStreamException
3842 {
3843 returnAST=null;
3844 ASTPair currentAST=new ASTPair();
3845 AST multiplicativeExpression_AST=null;
3846 unaryExpression();
3847 astFactory.addASTChild(currentAST, returnAST);
3848 {
3849 _loop162:
3850
3851 do {
3852 if(_tokenSet_22.member(LA(1))) {
3853 {
3854 switch(LA(1)) {
3855 case STAR:
3856
3857 {
3858 AST tmp133_AST=null;
3859 tmp133_AST=astFactory.create(LT(1));
3860 astFactory.makeASTRoot(currentAST,
3861 tmp133_AST);
3862 match(STAR);
3863 break;
3864 }
3865 case DIV:
3866
3867 {
3868 AST tmp134_AST=null;
3869 tmp134_AST=astFactory.create(LT(1));
3870 astFactory.makeASTRoot(currentAST,
3871 tmp134_AST);
3872 match(DIV);
3873 break;
3874 }
3875 case MOD:
3876
3877 {
3878 AST tmp135_AST=null;
3879 tmp135_AST=astFactory.create(LT(1));
3880 astFactory.makeASTRoot(currentAST,
3881 tmp135_AST);
3882 match(MOD);
3883 break;
3884 }
3885 default:
3886
3887 {
3888 throw new NoViableAltException(LT(1),
3889 getFilename());
3890 }
3891 }
3892 }
3893 unaryExpression();
3894 astFactory.addASTChild(currentAST, returnAST);
3895 } else {
3896 break _loop162;
3897 }
3898 } while(true);
3899
3900 }
3901 multiplicativeExpression_AST=(AST)currentAST.root;
3902 returnAST=multiplicativeExpression_AST;
3903 }
3904 /***
3905 */
3906 public final void unaryExpression() throws RecognitionException,
3907 TokenStreamException
3908 {
3909 returnAST=null;
3910 ASTPair currentAST=new ASTPair();
3911 AST unaryExpression_AST=null;
3912 switch(LA(1)) {
3913 case INC:
3914
3915 {
3916 AST tmp136_AST=null;
3917 tmp136_AST=astFactory.create(LT(1));
3918 astFactory.makeASTRoot(currentAST, tmp136_AST);
3919 match(INC);
3920 unaryExpression();
3921 astFactory.addASTChild(currentAST, returnAST);
3922 unaryExpression_AST=(AST)currentAST.root;
3923 break;
3924 }
3925 case DEC:
3926
3927 {
3928 AST tmp137_AST=null;
3929 tmp137_AST=astFactory.create(LT(1));
3930 astFactory.makeASTRoot(currentAST, tmp137_AST);
3931 match(DEC);
3932 unaryExpression();
3933 astFactory.addASTChild(currentAST, returnAST);
3934 unaryExpression_AST=(AST)currentAST.root;
3935 break;
3936 }
3937 case MINUS:
3938
3939 {
3940 AST tmp138_AST=null;
3941 tmp138_AST=astFactory.create(LT(1));
3942 astFactory.makeASTRoot(currentAST, tmp138_AST);
3943 match(MINUS);
3944 if(inputState.guessing==0) {
3945 tmp138_AST.setType(UNARY_MINUS);
3946 }
3947 unaryExpression();
3948 astFactory.addASTChild(currentAST, returnAST);
3949 unaryExpression_AST=(AST)currentAST.root;
3950 break;
3951 }
3952 case PLUS:
3953
3954 {
3955 AST tmp139_AST=null;
3956 tmp139_AST=astFactory.create(LT(1));
3957 astFactory.makeASTRoot(currentAST, tmp139_AST);
3958 match(PLUS);
3959 if(inputState.guessing==0) {
3960 tmp139_AST.setType(UNARY_PLUS);
3961 }
3962 unaryExpression();
3963 astFactory.addASTChild(currentAST, returnAST);
3964 unaryExpression_AST=(AST)currentAST.root;
3965 break;
3966 }
3967 case LITERAL_void:
3968 case LITERAL_boolean:
3969 case LITERAL_byte:
3970 case LITERAL_char:
3971 case LITERAL_short:
3972 case LITERAL_int:
3973 case LITERAL_float:
3974 case LITERAL_long:
3975 case LITERAL_double:
3976 case IDENT:
3977 case LPAREN:
3978 case LITERAL_this:
3979 case LITERAL_super:
3980 case BNOT:
3981 case LNOT:
3982 case LITERAL_true:
3983 case LITERAL_false:
3984 case LITERAL_null:
3985 case LITERAL_new:
3986 case NUM_INT:
3987 case CHAR_LITERAL:
3988 case STRING_LITERAL:
3989 case NUM_FLOAT:
3990 case NUM_LONG:
3991 case NUM_DOUBLE:
3992
3993 {
3994 unaryExpressionNotPlusMinus();
3995 astFactory.addASTChild(currentAST, returnAST);
3996 unaryExpression_AST=(AST)currentAST.root;
3997 break;
3998 }
3999 default:
4000
4001 {
4002 throw new NoViableAltException(LT(1), getFilename());
4003 }
4004 }
4005 returnAST=unaryExpression_AST;
4006 }
4007 /***
4008 */
4009 public final void unaryExpressionNotPlusMinus() throws RecognitionException,
4010 TokenStreamException
4011 {
4012 returnAST=null;
4013 ASTPair currentAST=new ASTPair();
4014 AST unaryExpressionNotPlusMinus_AST=null;
4015 Token lpb=null;
4016 AST lpb_AST=null;
4017 Token lp=null;
4018 AST lp_AST=null;
4019 switch(LA(1)) {
4020 case BNOT:
4021
4022 {
4023 AST tmp140_AST=null;
4024 tmp140_AST=astFactory.create(LT(1));
4025 astFactory.makeASTRoot(currentAST, tmp140_AST);
4026 match(BNOT);
4027 unaryExpression();
4028 astFactory.addASTChild(currentAST, returnAST);
4029 unaryExpressionNotPlusMinus_AST=(AST)currentAST.root;
4030 break;
4031 }
4032 case LNOT:
4033
4034 {
4035 AST tmp141_AST=null;
4036 tmp141_AST=astFactory.create(LT(1));
4037 astFactory.makeASTRoot(currentAST, tmp141_AST);
4038 match(LNOT);
4039 unaryExpression();
4040 astFactory.addASTChild(currentAST, returnAST);
4041 unaryExpressionNotPlusMinus_AST=(AST)currentAST.root;
4042 break;
4043 }
4044 case LITERAL_void:
4045 case LITERAL_boolean:
4046 case LITERAL_byte:
4047 case LITERAL_char:
4048 case LITERAL_short:
4049 case LITERAL_int:
4050 case LITERAL_float:
4051 case LITERAL_long:
4052 case LITERAL_double:
4053 case IDENT:
4054 case LPAREN:
4055 case LITERAL_this:
4056 case LITERAL_super:
4057 case LITERAL_true:
4058 case LITERAL_false:
4059 case LITERAL_null:
4060 case LITERAL_new:
4061 case NUM_INT:
4062 case CHAR_LITERAL:
4063 case STRING_LITERAL:
4064 case NUM_FLOAT:
4065 case NUM_LONG:
4066 case NUM_DOUBLE:
4067
4068 {
4069 {
4070 if(LA(1)==LPAREN&&LA(2)>=LITERAL_void&&
4071 LA(2)<=LITERAL_double) {
4072 lpb=LT(1);
4073 lpb_AST=astFactory.create(lpb);
4074 astFactory.makeASTRoot(currentAST, lpb_AST);
4075 match(LPAREN);
4076 if(inputState.guessing==0) {
4077 lpb_AST.setType(TYPECAST);
4078 }
4079 builtInTypeSpec(true);
4080 astFactory.addASTChild(currentAST, returnAST);
4081 match(RPAREN);
4082 unaryExpression();
4083 astFactory.addASTChild(currentAST, returnAST);
4084 } else {
4085 boolean synPredMatched167=false;
4086 if(LA(1)==LPAREN&&LA(2)==IDENT) {
4087 int _m167=mark();
4088 synPredMatched167=true;
4089 inputState.guessing++;
4090 try{
4091 {
4092 match(LPAREN);
4093 classTypeSpec(true);
4094 match(RPAREN);
4095 unaryExpressionNotPlusMinus();
4096 }
4097 }catch (RecognitionException pe) {
4098 synPredMatched167=false;
4099 }
4100 rewind(_m167);
4101 inputState.guessing--;
4102 }
4103 if(synPredMatched167) {
4104 lp=LT(1);
4105 lp_AST=astFactory.create(lp);
4106 astFactory.makeASTRoot(currentAST, lp_AST);
4107 match(LPAREN);
4108 if(inputState.guessing==0) {
4109 lp_AST.setType(TYPECAST);
4110 }
4111 classTypeSpec(true);
4112 astFactory.addASTChild(currentAST, returnAST);
4113 match(RPAREN);
4114 unaryExpressionNotPlusMinus();
4115 astFactory.addASTChild(currentAST, returnAST);
4116 } else if(_tokenSet_23.member(LA(1))&&_tokenSet_24.member(LA(2))) {
4117 postfixExpression();
4118 astFactory.addASTChild(currentAST, returnAST);
4119 } else {
4120 throw new NoViableAltException(LT(1),
4121 getFilename());
4122 }
4123 }
4124 }
4125 unaryExpressionNotPlusMinus_AST=(AST)currentAST.root;
4126 break;
4127 }
4128 default:
4129
4130 {
4131 throw new NoViableAltException(LT(1), getFilename());
4132 }
4133 }
4134 returnAST=unaryExpressionNotPlusMinus_AST;
4135 }
4136 /***
4137 */
4138 public final void postfixExpression() throws RecognitionException,
4139 TokenStreamException
4140 {
4141 returnAST=null;
4142 ASTPair currentAST=new ASTPair();
4143 AST postfixExpression_AST=null;
4144 Token lp=null;
4145 AST lp_AST=null;
4146 Token lp3=null;
4147 AST lp3_AST=null;
4148 Token lps=null;
4149 AST lps_AST=null;
4150 Token lb=null;
4151 AST lb_AST=null;
4152 Token in=null;
4153 AST in_AST=null;
4154 Token de=null;
4155 AST de_AST=null;
4156 primaryExpression();
4157 astFactory.addASTChild(currentAST, returnAST);
4158 {
4159 _loop173:
4160
4161 do {
4162 if(LA(1)==DOT&&LA(2)==IDENT) {
4163 AST tmp144_AST=null;
4164 tmp144_AST=astFactory.create(LT(1));
4165 astFactory.makeASTRoot(currentAST, tmp144_AST);
4166 match(DOT);
4167 AST tmp145_AST=null;
4168 tmp145_AST=astFactory.create(LT(1));
4169 astFactory.addASTChild(currentAST, tmp145_AST);
4170 match(IDENT);
4171 {
4172 switch(LA(1)) {
4173 case LPAREN:
4174
4175 {
4176 lp=LT(1);
4177 lp_AST=astFactory.create(lp);
4178 astFactory.makeASTRoot(currentAST,
4179 lp_AST);
4180 match(LPAREN);
4181 if(inputState.guessing==0) {
4182 lp_AST.setType(METHOD_CALL);
4183 }
4184 argList();
4185 astFactory.addASTChild(currentAST,
4186 returnAST);
4187 match(RPAREN);
4188 break;
4189 }
4190 case SEMI:
4191 case LBRACK:
4192 case RBRACK:
4193 case DOT:
4194 case STAR:
4195 case RCURLY:
4196 case COMMA:
4197 case RPAREN:
4198 case ASSIGN:
4199 case COLON:
4200 case PLUS_ASSIGN:
4201 case MINUS_ASSIGN:
4202 case STAR_ASSIGN:
4203 case DIV_ASSIGN:
4204 case MOD_ASSIGN:
4205 case SR_ASSIGN:
4206 case BSR_ASSIGN:
4207 case SL_ASSIGN:
4208 case BAND_ASSIGN:
4209 case BXOR_ASSIGN:
4210 case BOR_ASSIGN:
4211 case QUESTION:
4212 case LOR:
4213 case LAND:
4214 case BOR:
4215 case BXOR:
4216 case BAND:
4217 case NOT_EQUAL:
4218 case EQUAL:
4219 case LT:
4220 case GT:
4221 case LE:
4222 case GE:
4223 case LITERAL_instanceof:
4224 case SL:
4225 case SR:
4226 case BSR:
4227 case PLUS:
4228 case MINUS:
4229 case DIV:
4230 case MOD:
4231 case INC:
4232 case DEC:
4233
4234 {
4235 break;
4236 }
4237 default:
4238
4239 {
4240 throw new NoViableAltException(LT(1),
4241 getFilename());
4242 }
4243 }
4244 }
4245 } else if(LA(1)==DOT&&LA(2)==LITERAL_this) {
4246 AST tmp147_AST=null;
4247 tmp147_AST=astFactory.create(LT(1));
4248 astFactory.makeASTRoot(currentAST, tmp147_AST);
4249 match(DOT);
4250 AST tmp148_AST=null;
4251 tmp148_AST=astFactory.create(LT(1));
4252 astFactory.addASTChild(currentAST, tmp148_AST);
4253 match(LITERAL_this);
4254 } else if(LA(1)==DOT&&LA(2)==LITERAL_super) {
4255 AST tmp149_AST=null;
4256 tmp149_AST=astFactory.create(LT(1));
4257 astFactory.makeASTRoot(currentAST, tmp149_AST);
4258 match(DOT);
4259 AST tmp150_AST=null;
4260 tmp150_AST=astFactory.create(LT(1));
4261 astFactory.addASTChild(currentAST, tmp150_AST);
4262 match(LITERAL_super);
4263 {
4264 switch(LA(1)) {
4265 case LPAREN:
4266
4267 {
4268 lp3=LT(1);
4269 lp3_AST=astFactory.create(lp3);
4270 astFactory.makeASTRoot(currentAST,
4271 lp3_AST);
4272 match(LPAREN);
4273 argList();
4274 astFactory.addASTChild(currentAST,
4275 returnAST);
4276 match(RPAREN);
4277 if(inputState.guessing==0) {
4278 lp3_AST.setType(SUPER_CTOR_CALL);
4279 }
4280 break;
4281 }
4282 case DOT:
4283
4284 {
4285 AST tmp152_AST=null;
4286 tmp152_AST=astFactory.create(LT(1));
4287 astFactory.makeASTRoot(currentAST,
4288 tmp152_AST);
4289 match(DOT);
4290 AST tmp153_AST=null;
4291 tmp153_AST=astFactory.create(LT(1));
4292 astFactory.addASTChild(currentAST,
4293 tmp153_AST);
4294 match(IDENT);
4295 {
4296 switch(LA(1)) {
4297 case LPAREN:
4298
4299 {
4300 lps=LT(1);
4301 lps_AST=astFactory.create(lps);
4302 astFactory.makeASTRoot(currentAST,
4303 lps_AST);
4304 match(LPAREN);
4305 if(inputState.guessing==0) {
4306 lps_AST.setType(METHOD_CALL);
4307 }
4308 argList();
4309 astFactory.addASTChild(currentAST,
4310 returnAST);
4311 match(RPAREN);
4312 break;
4313 }
4314 case SEMI:
4315 case LBRACK:
4316 case RBRACK:
4317 case DOT:
4318 case STAR:
4319 case RCURLY:
4320 case COMMA:
4321 case RPAREN:
4322 case ASSIGN:
4323 case COLON:
4324 case PLUS_ASSIGN:
4325 case MINUS_ASSIGN:
4326 case STAR_ASSIGN:
4327 case DIV_ASSIGN:
4328 case MOD_ASSIGN:
4329 case SR_ASSIGN:
4330 case BSR_ASSIGN:
4331 case SL_ASSIGN:
4332 case BAND_ASSIGN:
4333 case BXOR_ASSIGN:
4334 case BOR_ASSIGN:
4335 case QUESTION:
4336 case LOR:
4337 case LAND:
4338 case BOR:
4339 case BXOR:
4340 case BAND:
4341 case NOT_EQUAL:
4342 case EQUAL:
4343 case LT:
4344 case GT:
4345 case LE:
4346 case GE:
4347 case LITERAL_instanceof:
4348 case SL:
4349 case SR:
4350 case BSR:
4351 case PLUS:
4352 case MINUS:
4353 case DIV:
4354 case MOD:
4355 case INC:
4356 case DEC:
4357
4358 {
4359 break;
4360 }
4361 default:
4362
4363 {
4364 throw new NoViableAltException(LT(1),
4365 getFilename());
4366 }
4367 }
4368 }
4369 break;
4370 }
4371 default:
4372
4373 {
4374 throw new NoViableAltException(LT(1),
4375 getFilename());
4376 }
4377 }
4378 }
4379 } else if(LA(1)==DOT&&LA(2)==LITERAL_new) {
4380 AST tmp155_AST=null;
4381 tmp155_AST=astFactory.create(LT(1));
4382 astFactory.makeASTRoot(currentAST, tmp155_AST);
4383 match(DOT);
4384 newExpression();
4385 astFactory.addASTChild(currentAST, returnAST);
4386 } else if(LA(1)==LBRACK) {
4387 lb=LT(1);
4388 lb_AST=astFactory.create(lb);
4389 astFactory.makeASTRoot(currentAST, lb_AST);
4390 match(LBRACK);
4391 if(inputState.guessing==0) {
4392 lb_AST.setType(INDEX_OP);
4393 }
4394 expression();
4395 astFactory.addASTChild(currentAST, returnAST);
4396 match(RBRACK);
4397 } else {
4398 break _loop173;
4399 }
4400 } while(true);
4401
4402 }
4403 {
4404 switch(LA(1)) {
4405 case INC:
4406
4407 {
4408 in=LT(1);
4409 in_AST=astFactory.create(in);
4410 astFactory.makeASTRoot(currentAST, in_AST);
4411 match(INC);
4412 if(inputState.guessing==0) {
4413 in_AST.setType(POST_INC);
4414 }
4415 break;
4416 }
4417 case DEC:
4418
4419 {
4420 de=LT(1);
4421 de_AST=astFactory.create(de);
4422 astFactory.makeASTRoot(currentAST, de_AST);
4423 match(DEC);
4424 if(inputState.guessing==0) {
4425 de_AST.setType(POST_DEC);
4426 }
4427 break;
4428 }
4429 case SEMI:
4430 case RBRACK:
4431 case STAR:
4432 case RCURLY:
4433 case COMMA:
4434 case RPAREN:
4435 case ASSIGN:
4436 case COLON:
4437 case PLUS_ASSIGN:
4438 case MINUS_ASSIGN:
4439 case STAR_ASSIGN:
4440 case DIV_ASSIGN:
4441 case MOD_ASSIGN:
4442 case SR_ASSIGN:
4443 case BSR_ASSIGN:
4444 case SL_ASSIGN:
4445 case BAND_ASSIGN:
4446 case BXOR_ASSIGN:
4447 case BOR_ASSIGN:
4448 case QUESTION:
4449 case LOR:
4450 case LAND:
4451 case BOR:
4452 case BXOR:
4453 case BAND:
4454 case NOT_EQUAL:
4455 case EQUAL:
4456 case LT:
4457 case GT:
4458 case LE:
4459 case GE:
4460 case LITERAL_instanceof:
4461 case SL:
4462 case SR:
4463 case BSR:
4464 case PLUS:
4465 case MINUS:
4466 case DIV:
4467 case MOD:
4468
4469 {
4470 break;
4471 }
4472 default:
4473
4474 {
4475 throw new NoViableAltException(LT(1), getFilename());
4476 }
4477 }
4478 }
4479 postfixExpression_AST=(AST)currentAST.root;
4480 returnAST=postfixExpression_AST;
4481 }
4482 /***
4483 */
4484 public final void primaryExpression() throws RecognitionException,
4485 TokenStreamException
4486 {
4487 returnAST=null;
4488 ASTPair currentAST=new ASTPair();
4489 AST primaryExpression_AST=null;
4490 Token lbt=null;
4491 AST lbt_AST=null;
4492 switch(LA(1)) {
4493 case IDENT:
4494
4495 {
4496 identPrimary();
4497 astFactory.addASTChild(currentAST, returnAST);
4498 {
4499 if(LA(1)==DOT&&LA(2)==LITERAL_class) {
4500 AST tmp157_AST=null;
4501 tmp157_AST=astFactory.create(LT(1));
4502 astFactory.makeASTRoot(currentAST, tmp157_AST);
4503 match(DOT);
4504 AST tmp158_AST=null;
4505 tmp158_AST=astFactory.create(LT(1));
4506 astFactory.addASTChild(currentAST, tmp158_AST);
4507 match(LITERAL_class);
4508 } else if(_tokenSet_25.member(LA(1))&&_tokenSet_26.member(LA(2))) {
4509 } else {
4510 throw new NoViableAltException(LT(1),
4511 getFilename());
4512 }
4513 }
4514 primaryExpression_AST=(AST)currentAST.root;
4515 break;
4516 }
4517 case NUM_INT:
4518 case CHAR_LITERAL:
4519 case STRING_LITERAL:
4520 case NUM_FLOAT:
4521 case NUM_LONG:
4522 case NUM_DOUBLE:
4523
4524 {
4525 constant();
4526 astFactory.addASTChild(currentAST, returnAST);
4527 primaryExpression_AST=(AST)currentAST.root;
4528 break;
4529 }
4530 case LITERAL_true:
4531
4532 {
4533 AST tmp159_AST=null;
4534 tmp159_AST=astFactory.create(LT(1));
4535 astFactory.addASTChild(currentAST, tmp159_AST);
4536 match(LITERAL_true);
4537 primaryExpression_AST=(AST)currentAST.root;
4538 break;
4539 }
4540 case LITERAL_false:
4541
4542 {
4543 AST tmp160_AST=null;
4544 tmp160_AST=astFactory.create(LT(1));
4545 astFactory.addASTChild(currentAST, tmp160_AST);
4546 match(LITERAL_false);
4547 primaryExpression_AST=(AST)currentAST.root;
4548 break;
4549 }
4550 case LITERAL_null:
4551
4552 {
4553 AST tmp161_AST=null;
4554 tmp161_AST=astFactory.create(LT(1));
4555 astFactory.addASTChild(currentAST, tmp161_AST);
4556 match(LITERAL_null);
4557 primaryExpression_AST=(AST)currentAST.root;
4558 break;
4559 }
4560 case LITERAL_new:
4561
4562 {
4563 newExpression();
4564 astFactory.addASTChild(currentAST, returnAST);
4565 primaryExpression_AST=(AST)currentAST.root;
4566 break;
4567 }
4568 case LITERAL_this:
4569
4570 {
4571 AST tmp162_AST=null;
4572 tmp162_AST=astFactory.create(LT(1));
4573 astFactory.addASTChild(currentAST, tmp162_AST);
4574 match(LITERAL_this);
4575 primaryExpression_AST=(AST)currentAST.root;
4576 break;
4577 }
4578 case LITERAL_super:
4579
4580 {
4581 AST tmp163_AST=null;
4582 tmp163_AST=astFactory.create(LT(1));
4583 astFactory.addASTChild(currentAST, tmp163_AST);
4584 match(LITERAL_super);
4585 primaryExpression_AST=(AST)currentAST.root;
4586 break;
4587 }
4588 case LPAREN:
4589
4590 {
4591 match(LPAREN);
4592 assignmentExpression();
4593 astFactory.addASTChild(currentAST, returnAST);
4594 match(RPAREN);
4595 primaryExpression_AST=(AST)currentAST.root;
4596 break;
4597 }
4598 case LITERAL_void:
4599 case LITERAL_boolean:
4600 case LITERAL_byte:
4601 case LITERAL_char:
4602 case LITERAL_short:
4603 case LITERAL_int:
4604 case LITERAL_float:
4605 case LITERAL_long:
4606 case LITERAL_double:
4607
4608 {
4609 builtInType();
4610 astFactory.addASTChild(currentAST, returnAST);
4611 {
4612 _loop178:
4613
4614 do {
4615 if(LA(1)==LBRACK) {
4616 lbt=LT(1);
4617 lbt_AST=astFactory.create(lbt);
4618 astFactory.makeASTRoot(currentAST,
4619 lbt_AST);
4620 match(LBRACK);
4621 if(inputState.guessing==0) {
4622 lbt_AST.setType(ARRAY_DECLARATOR);
4623 }
4624 match(RBRACK);
4625 } else {
4626 break _loop178;
4627 }
4628 } while(true);
4629
4630 }
4631 AST tmp167_AST=null;
4632 tmp167_AST=astFactory.create(LT(1));
4633 astFactory.makeASTRoot(currentAST, tmp167_AST);
4634 match(DOT);
4635 AST tmp168_AST=null;
4636 tmp168_AST=astFactory.create(LT(1));
4637 astFactory.addASTChild(currentAST, tmp168_AST);
4638 match(LITERAL_class);
4639 primaryExpression_AST=(AST)currentAST.root;
4640 break;
4641 }
4642 default:
4643
4644 {
4645 throw new NoViableAltException(LT(1), getFilename());
4646 }
4647 }
4648 returnAST=primaryExpression_AST;
4649 }
4650 /***
4651 * object instantiation. Trees are built as illustrated by the
4652 * following input/tree pairs: new T() new | T -- ELIST | arg1 -- arg2
4653 * -- .. -- argn new int[] new | int -- ARRAY_DECLARATOR new int[]
4654 * {1,2} new | int -- ARRAY_DECLARATOR -- ARRAY_INIT | EXPR -- EXPR |
4655 * | 1 2 new int[3] new | int -- ARRAY_DECLARATOR | EXPR | 3 new
4656 * int[1][2] new | int -- ARRAY_DECLARATOR | ARRAY_DECLARATOR -- EXPR
4657 * | | EXPR 1 | 2
4658 */
4659 public final void newExpression() throws RecognitionException,
4660 TokenStreamException
4661 {
4662 returnAST=null;
4663 ASTPair currentAST=new ASTPair();
4664 AST newExpression_AST=null;
4665 Token n=null;
4666 AST n_AST=null;
4667 n=LT(1);
4668 n_AST=astFactory.create(n);
4669 astFactory.makeASTRoot(currentAST, n_AST);
4670 match(LITERAL_new);
4671 type();
4672 astFactory.addASTChild(currentAST, returnAST);
4673 {
4674 switch(LA(1)) {
4675 case LPAREN:
4676
4677 {
4678 match(LPAREN);
4679 argList();
4680 astFactory.addASTChild(currentAST, returnAST);
4681 match(RPAREN);
4682 {
4683 switch(LA(1)) {
4684 case LCURLY:
4685
4686 {
4687 classBlock();
4688 astFactory.addASTChild(currentAST,
4689 returnAST);
4690 break;
4691 }
4692 case SEMI:
4693 case LBRACK:
4694 case RBRACK:
4695 case DOT:
4696 case STAR:
4697 case RCURLY:
4698 case COMMA:
4699 case RPAREN:
4700 case ASSIGN:
4701 case COLON:
4702 case PLUS_ASSIGN:
4703 case MINUS_ASSIGN:
4704 case STAR_ASSIGN:
4705 case DIV_ASSIGN:
4706 case MOD_ASSIGN:
4707 case SR_ASSIGN:
4708 case BSR_ASSIGN:
4709 case SL_ASSIGN:
4710 case BAND_ASSIGN:
4711 case BXOR_ASSIGN:
4712 case BOR_ASSIGN:
4713 case QUESTION:
4714 case LOR:
4715 case LAND:
4716 case BOR:
4717 case BXOR:
4718 case BAND:
4719 case NOT_EQUAL:
4720 case EQUAL:
4721 case LT:
4722 case GT:
4723 case LE:
4724 case GE:
4725 case LITERAL_instanceof:
4726 case SL:
4727 case SR:
4728 case BSR:
4729 case PLUS:
4730 case MINUS:
4731 case DIV:
4732 case MOD:
4733 case INC:
4734 case DEC:
4735
4736 {
4737 break;
4738 }
4739 default:
4740
4741 {
4742 throw new NoViableAltException(LT(1),
4743 getFilename());
4744 }
4745 }
4746 }
4747 break;
4748 }
4749 case LBRACK:
4750
4751 {
4752 newArrayDeclarator();
4753 astFactory.addASTChild(currentAST, returnAST);
4754 {
4755 switch(LA(1)) {
4756 case LCURLY:
4757
4758 {
4759 arrayInitializer();
4760 astFactory.addASTChild(currentAST,
4761 returnAST);
4762 break;
4763 }
4764 case SEMI:
4765 case LBRACK:
4766 case RBRACK:
4767 case DOT:
4768 case STAR:
4769 case RCURLY:
4770 case COMMA:
4771 case RPAREN:
4772 case ASSIGN:
4773 case COLON:
4774 case PLUS_ASSIGN:
4775 case MINUS_ASSIGN:
4776 case STAR_ASSIGN:
4777 case DIV_ASSIGN:
4778 case MOD_ASSIGN:
4779 case SR_ASSIGN:
4780 case BSR_ASSIGN:
4781 case SL_ASSIGN:
4782 case BAND_ASSIGN:
4783 case BXOR_ASSIGN:
4784 case BOR_ASSIGN:
4785 case QUESTION:
4786 case LOR:
4787 case LAND:
4788 case BOR:
4789 case BXOR:
4790 case BAND:
4791 case NOT_EQUAL:
4792 case EQUAL:
4793 case LT:
4794 case GT:
4795 case LE:
4796 case GE:
4797 case LITERAL_instanceof:
4798 case SL:
4799 case SR:
4800 case BSR:
4801 case PLUS:
4802 case MINUS:
4803 case DIV:
4804 case MOD:
4805 case INC:
4806 case DEC:
4807
4808 {
4809 break;
4810 }
4811 default:
4812
4813 {
4814 throw new NoViableAltException(LT(1),
4815 getFilename());
4816 }
4817 }
4818 }
4819 break;
4820 }
4821 default:
4822
4823 {
4824 throw new NoViableAltException(LT(1), getFilename());
4825 }
4826 }
4827 }
4828 if(inputState.guessing==0) {
4829 n_AST.setType(NEW_EXPRESSION);
4830 }
4831 newExpression_AST=(AST)currentAST.root;
4832 returnAST=newExpression_AST;
4833 }
4834 /***
4835 * Match a, a.b.c refs, a.b.c(...) refs, a.b.c[], a.b.c[].class, and
4836 * a.b.c.class refs. Also this(...) and super(...). Match this or
4837 * super.
4838 */
4839 public final void identPrimary() throws RecognitionException,
4840 TokenStreamException
4841 {
4842 returnAST=null;
4843 ASTPair currentAST=new ASTPair();
4844 AST identPrimary_AST=null;
4845 Token lp=null;
4846 AST lp_AST=null;
4847 Token lbc=null;
4848 AST lbc_AST=null;
4849 AST tmp171_AST=null;
4850 tmp171_AST=astFactory.create(LT(1));
4851 astFactory.addASTChild(currentAST, tmp171_AST);
4852 match(IDENT);
4853 {
4854 _loop181:
4855
4856 do {
4857 if(LA(1)==DOT&&LA(2)==IDENT) {
4858 AST tmp172_AST=null;
4859 tmp172_AST=astFactory.create(LT(1));
4860 astFactory.makeASTRoot(currentAST, tmp172_AST);
4861 match(DOT);
4862 AST tmp173_AST=null;
4863 tmp173_AST=astFactory.create(LT(1));
4864 astFactory.addASTChild(currentAST, tmp173_AST);
4865 match(IDENT);
4866 } else {
4867 break _loop181;
4868 }
4869 } while(true);
4870
4871 }
4872 {
4873 if(LA(1)==LPAREN) {
4874 {
4875 lp=LT(1);
4876 lp_AST=astFactory.create(lp);
4877 astFactory.makeASTRoot(currentAST, lp_AST);
4878 match(LPAREN);
4879 if(inputState.guessing==0) {
4880 lp_AST.setType(METHOD_CALL);
4881 }
4882 argList();
4883 astFactory.addASTChild(currentAST, returnAST);
4884 match(RPAREN);
4885 }
4886 } else if(LA(1)==LBRACK&&LA(2)==RBRACK) {
4887 {
4888 int _cnt185=0;
4889 _loop185:
4890
4891 do {
4892 if(LA(1)==LBRACK&&LA(2)==RBRACK) {
4893 lbc=LT(1);
4894 lbc_AST=astFactory.create(lbc);
4895 astFactory.makeASTRoot(currentAST,
4896 lbc_AST);
4897 match(LBRACK);
4898 if(inputState.guessing==0) {
4899 lbc_AST.setType(ARRAY_DECLARATOR);
4900 }
4901 match(RBRACK);
4902 } else {
4903 if(_cnt185>=1) {
4904 break _loop185;
4905 } else {
4906 throw new NoViableAltException(LT(1),
4907 getFilename());
4908 }
4909 }
4910 _cnt185++;
4911 } while(true);
4912
4913 }
4914 } else if(_tokenSet_25.member(LA(1))&&_tokenSet_26.member(LA(2))) {
4915 } else {
4916 throw new NoViableAltException(LT(1), getFilename());
4917 }
4918 }
4919 identPrimary_AST=(AST)currentAST.root;
4920 returnAST=identPrimary_AST;
4921 }
4922 /***
4923 */
4924 public final void constant() throws RecognitionException,
4925 TokenStreamException
4926 {
4927 returnAST=null;
4928 ASTPair currentAST=new ASTPair();
4929 AST constant_AST=null;
4930 switch(LA(1)) {
4931 case NUM_INT:
4932
4933 {
4934 AST tmp176_AST=null;
4935 tmp176_AST=astFactory.create(LT(1));
4936 astFactory.addASTChild(currentAST, tmp176_AST);
4937 match(NUM_INT);
4938 constant_AST=(AST)currentAST.root;
4939 break;
4940 }
4941 case CHAR_LITERAL:
4942
4943 {
4944 AST tmp177_AST=null;
4945 tmp177_AST=astFactory.create(LT(1));
4946 astFactory.addASTChild(currentAST, tmp177_AST);
4947 match(CHAR_LITERAL);
4948 constant_AST=(AST)currentAST.root;
4949 break;
4950 }
4951 case STRING_LITERAL:
4952
4953 {
4954 AST tmp178_AST=null;
4955 tmp178_AST=astFactory.create(LT(1));
4956 astFactory.addASTChild(currentAST, tmp178_AST);
4957 match(STRING_LITERAL);
4958 constant_AST=(AST)currentAST.root;
4959 break;
4960 }
4961 case NUM_FLOAT:
4962
4963 {
4964 AST tmp179_AST=null;
4965 tmp179_AST=astFactory.create(LT(1));
4966 astFactory.addASTChild(currentAST, tmp179_AST);
4967 match(NUM_FLOAT);
4968 constant_AST=(AST)currentAST.root;
4969 break;
4970 }
4971 case NUM_LONG:
4972
4973 {
4974 AST tmp180_AST=null;
4975 tmp180_AST=astFactory.create(LT(1));
4976 astFactory.addASTChild(currentAST, tmp180_AST);
4977 match(NUM_LONG);
4978 constant_AST=(AST)currentAST.root;
4979 break;
4980 }
4981 case NUM_DOUBLE:
4982
4983 {
4984 AST tmp181_AST=null;
4985 tmp181_AST=astFactory.create(LT(1));
4986 astFactory.addASTChild(currentAST, tmp181_AST);
4987 match(NUM_DOUBLE);
4988 constant_AST=(AST)currentAST.root;
4989 break;
4990 }
4991 default:
4992
4993 {
4994 throw new NoViableAltException(LT(1), getFilename());
4995 }
4996 }
4997 returnAST=constant_AST;
4998 }
4999 /***
5000 */
5001 public final void newArrayDeclarator() throws RecognitionException,
5002 TokenStreamException
5003 {
5004 returnAST=null;
5005 ASTPair currentAST=new ASTPair();
5006 AST newArrayDeclarator_AST=null;
5007 Token lb=null;
5008 AST lb_AST=null;
5009 {
5010 int _cnt195=0;
5011 _loop195:
5012
5013 do {
5014 if(LA(1)==LBRACK&&_tokenSet_27.member(LA(2))) {
5015 lb=LT(1);
5016 lb_AST=astFactory.create(lb);
5017 astFactory.makeASTRoot(currentAST, lb_AST);
5018 match(LBRACK);
5019 if(inputState.guessing==0) {
5020 lb_AST.setType(ARRAY_DECLARATOR);
5021 }
5022 {
5023 switch(LA(1)) {
5024 case LITERAL_void:
5025 case LITERAL_boolean:
5026 case LITERAL_byte:
5027 case LITERAL_char:
5028 case LITERAL_short:
5029 case LITERAL_int:
5030 case LITERAL_float:
5031 case LITERAL_long:
5032 case LITERAL_double:
5033 case IDENT:
5034 case LPAREN:
5035 case LITERAL_this:
5036 case LITERAL_super:
5037 case PLUS:
5038 case MINUS:
5039 case INC:
5040 case DEC:
5041 case BNOT:
5042 case LNOT:
5043 case LITERAL_true:
5044 case LITERAL_false:
5045 case LITERAL_null:
5046 case LITERAL_new:
5047 case NUM_INT:
5048 case CHAR_LITERAL:
5049 case STRING_LITERAL:
5050 case NUM_FLOAT:
5051 case NUM_LONG:
5052 case NUM_DOUBLE:
5053
5054 {
5055 expression();
5056 astFactory.addASTChild(currentAST,
5057 returnAST);
5058 break;
5059 }
5060 case RBRACK:
5061
5062 {
5063 break;
5064 }
5065 default:
5066
5067 {
5068 throw new NoViableAltException(LT(1),
5069 getFilename());
5070 }
5071 }
5072 }
5073 match(RBRACK);
5074 } else {
5075 if(_cnt195>=1) {
5076 break _loop195;
5077 } else {
5078 throw new NoViableAltException(LT(1),
5079 getFilename());
5080 }
5081 }
5082 _cnt195++;
5083 } while(true);
5084
5085 }
5086 newArrayDeclarator_AST=(AST)currentAST.root;
5087 returnAST=newArrayDeclarator_AST;
5088 }
5089 public static final String[] _tokenNames={"<0>","EOF","<2>",
5090 "NULL_TREE_LOOKAHEAD","BLOCK","MODIFIERS","OBJBLOCK","SLIST",
5091 "CTOR_DEF","METHOD_DEF","VARIABLE_DEF","INSTANCE_INIT","STATIC_INIT",
5092 "TYPE","CLASS_DEF","INTERFACE_DEF","PACKAGE_DEF","ARRAY_DECLARATOR",
5093 "EXTENDS_CLAUSE","IMPLEMENTS_CLAUSE","PARAMETERS","PARAMETER_DEF",
5094 "LABELED_STAT","TYPECAST","INDEX_OP","POST_INC","POST_DEC",
5095 "METHOD_CALL","EXPR","ARRAY_INIT","IMPORT","UNARY_MINUS","UNARY_PLUS",
5096 "CASE_GROUP","ELIST","FOR_INIT","FOR_CONDITION","FOR_ITERATOR",
5097 "EMPTY_STAT","\"final\"","\"abstract\"","\"strictfp\"",
5098 "SUPER_CTOR_CALL","CTOR_CALL","TRY_BLOCK","NEW_EXPRESSION",
5099 "THROWS_CLAUSE","SYNCHRONIZED","FINALLY_CLAUSE","HANDLER","IF","THROW",
5100 "FOR","SWITCH","CASE","DO","RETURN","BREAK","CONTINUE","INSTANCEOF",
5101 "WHILE","JAVA_COMMENT","\"package\"","SEMI","\"import\"","LBRACK",
5102 "RBRACK","\"void\"","\"boolean\"","\"byte\"","\"char\"","\"short\"",
5103 "\"int\"","\"float\"","\"long\"","\"double\"","IDENT","DOT","STAR",
5104 "\"private\"","\"public\"","\"protected\"","\"static\"",
5105 "\"transient\"","\"native\"","\"threadsafe\"","\"synchronized\"",
5106 "\"volatile\"","\"class\"","\"extends\"","\"interface\"","LCURLY",
5107 "RCURLY","COMMA","\"implements\"","LPAREN","RPAREN","\"this\"",
5108 "\"super\"","ASSIGN","\"throws\"","COLON","\"if\"","\"else\"",
5109 "\"for\"","\"while\"","\"do\"","\"break\"","\"continue\"","\"return\"",
5110 "\"switch\"","\"throw\"","\"case\"","\"default\"","\"try\"",
5111 "\"finally\"","\"catch\"","PLUS_ASSIGN","MINUS_ASSIGN","STAR_ASSIGN",
5112 "DIV_ASSIGN","MOD_ASSIGN","SR_ASSIGN","BSR_ASSIGN","SL_ASSIGN",
5113 "BAND_ASSIGN","BXOR_ASSIGN","BOR_ASSIGN","QUESTION","LOR","LAND","BOR",
5114 "BXOR","BAND","NOT_EQUAL","EQUAL","LT","GT","LE","GE","\"instanceof\"",
5115 "SL","SR","BSR","PLUS","MINUS","DIV","MOD","INC","DEC","BNOT","LNOT",
5116 "\"true\"","\"false\"","\"null\"","\"new\"","NUM_INT","CHAR_LITERAL",
5117 "STRING_LITERAL","NUM_FLOAT","NUM_LONG","NUM_DOUBLE","WS","SL_COMMENT",
5118 "ML_COMMENT","ESC","HEX_DIGIT","VOCAB","EXPONENT","FLOAT_SUFFIX"};
5119 /***
5120 */
5121 protected void buildTokenTypeASTClassMap()
5122 {
5123 tokenTypeToASTClassMap=null;
5124 }
5125 /***
5126 * @return
5127 */
5128 private static final long[] mk_tokenSet_0()
5129 {
5130 long[] data={-9223368188564078592L,100630528L,0L,0L};
5131 return data;
5132 }
5133 public static final BitSet _tokenSet_0=new BitSet(mk_tokenSet_0());
5134 /***
5135 * @return
5136 */
5137 private static final long[] mk_tokenSet_1()
5138 {
5139 long[] data={-9223368188564078590L,100630529L,0L,0L};
5140 return data;
5141 }
5142 public static final BitSet _tokenSet_1=new BitSet(mk_tokenSet_1());
5143 /***
5144 * @return
5145 */
5146 private static final long[] mk_tokenSet_2()
5147 {
5148 long[] data={-9223368188564078590L,100630528L,0L,0L};
5149 return data;
5150 }
5151 public static final BitSet _tokenSet_2=new BitSet(mk_tokenSet_2());
5152 /***
5153 * @return
5154 */
5155 private static final long[] mk_tokenSet_3()
5156 {
5157 long[] data={3848290697216L,16744448L,0L,0L};
5158 return data;
5159 }
5160 public static final BitSet _tokenSet_3=new BitSet(mk_tokenSet_3());
5161 /***
5162 * @return
5163 */
5164 private static final long[] mk_tokenSet_4()
5165 {
5166 long[] data={3848290697216L,100638712L,0L,0L};
5167 return data;
5168 }
5169 public static final BitSet _tokenSet_4=new BitSet(mk_tokenSet_4());
5170 /***
5171 * @return
5172 */
5173 private static final long[] mk_tokenSet_5()
5174 {
5175 long[] data={3848290697216L,2248130554L,0L,0L};
5176 return data;
5177 }
5178 public static final BitSet _tokenSet_5=new BitSet(mk_tokenSet_5());
5179 /***
5180 * @return
5181 */
5182 private static final long[] mk_tokenSet_6()
5183 {
5184 long[] data={0L,12290L,0L,0L};
5185 return data;
5186 }
5187 public static final BitSet _tokenSet_6=new BitSet(mk_tokenSet_6());
5188 /***
5189 * @return
5190 */
5191 private static final long[] mk_tokenSet_7()
5192 {
5193 long[] data={-9223372036854775808L,34896609282L,0L,0L};
5194 return data;
5195 }
5196 public static final BitSet _tokenSet_7=new BitSet(mk_tokenSet_7());
5197 /***
5198 * @return
5199 */
5200 private static final long[] mk_tokenSet_8()
5201 {
5202 long[] data={-9223368188564078592L,1406578603302904L,17179017216L,
5203 0L,0L,0L};
5204 return data;
5205 }
5206 public static final BitSet _tokenSet_8=new BitSet(mk_tokenSet_8());
5207 /***
5208 * @return
5209 */
5210 private static final long[] mk_tokenSet_9()
5211 {
5212 long[] data={-9223368188564078592L,-7600448785612806L,17179869183L,
5213 0L,0L,0L};
5214 return data;
5215 }
5216 public static final BitSet _tokenSet_9=new BitSet(mk_tokenSet_9());
5217 /***
5218 * @return
5219 */
5220 private static final long[] mk_tokenSet_10()
5221 {
5222 long[] data={-9223368188564078592L,1406578334867448L,17179017216L,
5223 0L,0L,0L};
5224 return data;
5225 }
5226 public static final BitSet _tokenSet_10=new BitSet(mk_tokenSet_10());
5227 /***
5228 * @return
5229 */
5230 private static final long[] mk_tokenSet_11()
5231 {
5232 long[] data={-9223368188564078592L,2251553289248760L,17179017216L,
5233 0L,0L,0L};
5234 return data;
5235 }
5236 public static final BitSet _tokenSet_11=new BitSet(mk_tokenSet_11());
5237 /***
5238 * @return
5239 */
5240 private static final long[] mk_tokenSet_12()
5241 {
5242 long[] data={-9223368188564078592L,-74658611206L,17179869183L,0L,
5243 0L,0L};
5244 return data;
5245 }
5246 public static final BitSet _tokenSet_12=new BitSet(mk_tokenSet_12());
5247 /***
5248 * @return
5249 */
5250 private static final long[] mk_tokenSet_13()
5251 {
5252 long[] data={3848290697216L,16752632L,0L,0L};
5253 return data;
5254 }
5255 public static final BitSet _tokenSet_13=new BitSet(mk_tokenSet_13());
5256 /***
5257 * @return
5258 */
5259 private static final long[] mk_tokenSet_14()
5260 {
5261 long[] data={3848290697216L,16760826L,0L,0L};
5262 return data;
5263 }
5264 public static final BitSet _tokenSet_14=new BitSet(mk_tokenSet_14());
5265 /***
5266 * @return
5267 */
5268 private static final long[] mk_tokenSet_15()
5269 {
5270 long[] data={0L,27917295608L,17179017216L,0L,0L,0L};
5271 return data;
5272 }
5273 public static final BitSet _tokenSet_15=new BitSet(mk_tokenSet_15());
5274 /***
5275 * @return
5276 */
5277 private static final long[] mk_tokenSet_16()
5278 {
5279 long[] data={-9223372036854775808L,-9007136977682438L,17179869183L,
5280 0L,0L,0L};
5281 return data;
5282 }
5283 public static final BitSet _tokenSet_16=new BitSet(mk_tokenSet_16());
5284 /***
5285 * @return
5286 */
5287 private static final long[] mk_tokenSet_17()
5288 {
5289 long[] data={3848290697216L,33521664L,0L,0L};
5290 return data;
5291 }
5292 public static final BitSet _tokenSet_17=new BitSet(mk_tokenSet_17());
5293 /***
5294 * @return
5295 */
5296 private static final long[] mk_tokenSet_18()
5297 {
5298 long[] data={3848290697216L,33525760L,0L,0L};
5299 return data;
5300 }
5301 public static final BitSet _tokenSet_18=new BitSet(mk_tokenSet_18());
5302 /***
5303 * @return
5304 */
5305 private static final long[] mk_tokenSet_19()
5306 {
5307 long[] data={0L,28051513336L,17179017216L,0L,0L,0L};
5308 return data;
5309 }
5310 public static final BitSet _tokenSet_19=new BitSet(mk_tokenSet_19());
5311 /***
5312 * @return
5313 */
5314 private static final long[] mk_tokenSet_20()
5315 {
5316 long[] data={-9223372036854775808L,-9007136440811526L,17179869183L,
5317 0L,0L,0L};
5318 return data;
5319 }
5320 public static final BitSet _tokenSet_20=new BitSet(mk_tokenSet_20());
5321 /***
5322 * @return
5323 */
5324 private static final long[] mk_tokenSet_21()
5325 {
5326 long[] data={0L,165356249080L,17179017216L,0L,0L,0L};
5327 return data;
5328 }
5329 public static final BitSet _tokenSet_21=new BitSet(mk_tokenSet_21());
5330 /***
5331 * @return
5332 */
5333 private static final long[] mk_tokenSet_22()
5334 {
5335 long[] data={0L,16384L,786432L,0L,0L,0L};
5336 return data;
5337 }
5338 public static final BitSet _tokenSet_22=new BitSet(mk_tokenSet_22());
5339 /***
5340 * @return
5341 */
5342 private static final long[] mk_tokenSet_23()
5343 {
5344 long[] data={0L,27917295608L,17163091968L,0L,0L,0L};
5345 return data;
5346 }
5347 public static final BitSet _tokenSet_23=new BitSet(mk_tokenSet_23());
5348 /***
5349 * @return
5350 */
5351 private static final long[] mk_tokenSet_24()
5352 {
5353 long[] data={-9223372036854775808L,-9006994438455298L,17179869183L,
5354 0L,0L,0L};
5355 return data;
5356 }
5357 public static final BitSet _tokenSet_24=new BitSet(mk_tokenSet_24());
5358 /***
5359 * @return
5360 */
5361 private static final long[] mk_tokenSet_25()
5362 {
5363 long[] data={-9223372036854775808L,-9007022355750906L,4194303L,0L,
5364 0L,0L};
5365 return data;
5366 }
5367 public static final BitSet _tokenSet_25=new BitSet(mk_tokenSet_25());
5368 /***
5369 * @return
5370 */
5371 private static final long[] mk_tokenSet_26()
5372 {
5373 long[] data={-9223368188564078592L,-6755469267828738L,17179869183L,
5374 0L,0L,0L};
5375 return data;
5376 }
5377 public static final BitSet _tokenSet_26=new BitSet(mk_tokenSet_26());
5378 /***
5379 * @return
5380 */
5381 private static final long[] mk_tokenSet_27()
5382 {
5383 long[] data={0L,27917295612L,17179017216L,0L,0L,0L};
5384 return data;
5385 }
5386 public static final BitSet _tokenSet_27=new BitSet(mk_tokenSet_27());
5387 }
This page was automatically generated by Maven